{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys\n",
    "\n",
    "sys.path.append('/home/luo3300612/Workspace/PycharmWS/mySuperPoint/superpoint/model')\n",
    "\n",
    "import torch\n",
    "import matplotlib.pyplot as plt \n",
    "import torch.nn as nn\n",
    "from utils import SuperPointFrontend\n",
    "from data import get_test\n",
    "import numpy as np\n",
    "from dataset import point2label\n",
    "from tqdm import tqdm\n",
    "import random"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "net = torch.load('/home/luo3300612/Workspace/PycharmWS/mySuperPoint/superpoint/result/epoch130',map_location='cpu')\n",
    "# 120 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_data = get_test({\"SyntheticData\":{\"only_point\":True}},loader=False)\n",
    "sample_index = random.sample(range(4500),1000)\n",
    "test_sample = [test_data[i] for i in sample_index]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def pr_pts(heat_map,label,positive=True):\n",
    "    if positive:\n",
    "        index = list(reversed(np.argsort(heat_map,axis=None).tolist()))\n",
    "    else:\n",
    "        index = np.argsort(heat_map,axis=None).tolist()\n",
    "        label = np.logical_not(label)\n",
    "    \n",
    "    AP_positive = 0\n",
    "    pred_label = np.zeros_like(label,dtype=int)\n",
    "    \n",
    "    pr_curve = np.zeros((heat_map.shape[0]*heat_map.shape[1]+2,2))\n",
    "    pr_curve[0,0] = 0\n",
    "    pr_curve[0,1] = 1\n",
    "    pr_curve[-1,0] = 1\n",
    "    pr_curve[-1,1] = 0\n",
    "    \n",
    "    \n",
    "    pred_positive_sample_num = 0\n",
    "    precision_pts = []\n",
    "    for i in range(len(index)):\n",
    "        r,c = one2two(index[i],*heat_map.shape)\n",
    "        pred_label[r,c] = 1\n",
    "\n",
    "        pred_positive_sample_num += 1\n",
    "        positive_sample_num = np.sum(label)\n",
    "        \n",
    "        if positive_sample_num == 0:  # 剪枝            \n",
    "            for j in range(i,len(index)):\n",
    "                pr_curve[j+1,0] = 1  # recall = 1\n",
    "                pr_curve[j+1,1] = 0  # precision = 0\n",
    "            precision_pts.append([0,1])\n",
    "            # precision_pts.append([1,0])\n",
    "            break\n",
    "        else:\n",
    "            TP = np.sum(np.logical_and(pred_label,label))\n",
    "            precision = TP/pred_positive_sample_num\n",
    "            recall = TP/positive_sample_num\n",
    "            \n",
    "            if recall != 0 and recall != pr_curve[i,0]:\n",
    "                precision_pts.append([recall,precision])\n",
    "            \n",
    "            pr_curve[i+1,0] = recall\n",
    "            pr_curve[i+1,1] = precision\n",
    "    return pr_curve,np.array(precision_pts)\n",
    "            \n",
    "    \n",
    "def one2two(index,row,col):\n",
    "    r = index//col\n",
    "    c = index%col\n",
    "    return r,c\n",
    "\n",
    "\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "from utils import output2points"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_heatmap(sample):\n",
    "    img = sample['img']\n",
    "    pts = sample['pt']\n",
    "    img_tensor = torch.tensor(img)\n",
    "    img_tensor = img_tensor.view((1,1,*img.shape))\n",
    "    output = net(img_tensor)\n",
    "    output = output.squeeze()\n",
    "    output = np.exp(output.detach().numpy())  # Softmax.\n",
    "    output = output / (np.sum(output, axis=0) + .00001)  # Should sum to 1.\n",
    "    output = output[:-1, :, :]\n",
    "    output = output.transpose(1, 2, 0)\n",
    "    output = output.reshape((15, 20, 8, 8))\n",
    "    output = output.transpose(0, 2, 1, 3)\n",
    "    heatmap = output.reshape(120, 160)\n",
    "    return heatmap\n",
    "                                 \n",
    "def visulize_pr(sample):\n",
    "    \"\"\"\n",
    "    visulize p-r curve of an img\n",
    "    \"\"\"\n",
    "    img = sample['img']\n",
    "    pts = sample['pt']\n",
    "    label = point2label(pts,binary=True)\n",
    "    heatmap = get_heatmap(sample)\n",
    "                                 \n",
    "    pts,precision_pts= pr_pts(heatmap,label,True)\n",
    "\n",
    "    plt.plot(pts[:,0],pts[:,1])\n",
    "    plt.scatter(precision_pts[:,0],precision_pts[:,1],color='r')\n",
    "    plt.show()\n",
    "    plt.imshow(img)\n",
    "    plt.show()\n",
    "                                 \n",
    "def mAP(sample):\n",
    "    label = point2label(sample['pt'],binary=True)\n",
    "    heatmap = get_heatmap(sample)\n",
    "    pts_pos,precision_pts_pos = pr_pts(heatmap,label,True)\n",
    "    pts_ne,precision_ne = pr_pts(heatmap,label,False)\n",
    "    \n",
    "    mAP = (np.mean(precision_pts_pos[:,1]) + np.mean(precision_ne[:,1]))/2\n",
    "    return mAP"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 1000/1000 [32:45<00:00,  1.98s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "AVG. map = 0.8086\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "from tqdm import tqdm\n",
    "mAP_sum = 0\n",
    "for sample in tqdm(test_sample):\n",
    "    mAP_sum += mAP(sample)\n",
    "print(f\"AVG. map = {mAP_sum/1000:.4f}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 1000/1000 [32:13<00:00,  2.01s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "AVG. map = 0.8696\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "from tqdm import tqdm\n",
    "mAP_sum = 0\n",
    "for sample in tqdm(test_sample):\n",
    "    mAP_sum += mAP(sample)\n",
    "print(f\"AVG. map = {mAP_sum/1000:.4f}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def mAP_fix(test_sample):\n",
    "        \n",
    "    conf_list = []\n",
    "    label_list = []\n",
    "    \n",
    "    for sample in tqdm(test_sample):\n",
    "        heatmap = list(get_heatmap(sample).reshape((-1,)))\n",
    "        label = list(point2label(sample['pt'],binary=True).reshape((-1,)))\n",
    "        conf_list += heatmap\n",
    "        label_list += label\n",
    "    \n",
    "    conf_list = np.array(conf_list)\n",
    "    label = np.array(label_list)\n",
    "    \n",
    "    index = list(reversed(np.argsort(conf_list).tolist()))\n",
    "    \n",
    "    pred_label = np.zeros_like(conf_list)\n",
    "    \n",
    "    pred_positive_sample_num = 0\n",
    "    precision_pts = []\n",
    "    pr_curve = np.zeros((len(index)+2,2))\n",
    "    \n",
    "    pr_curve[0,0] = 0\n",
    "    pr_curve[0,1] = 1\n",
    "    pr_curve[-1,0] = 1\n",
    "    pr_curve[-1,1] = 0\n",
    "    \n",
    "    TP = 0\n",
    "    positive_sample_num = np.sum(label)\n",
    "    print(len(index))\n",
    "    for i in tqdm(range(len(index))):\n",
    "        \n",
    "        ind = index[i]\n",
    "        \n",
    "        pred_label[ind] = 1\n",
    "        \n",
    "        pred_positive_sample_num += 1\n",
    "        \n",
    "        \n",
    "        if label[ind] == 1:\n",
    "            TP += 1\n",
    "        precision = TP/pred_positive_sample_num\n",
    "        recall = TP/positive_sample_num\n",
    "        \n",
    "        if recall != 0 and recall != pr_curve[i,0]:\n",
    "            precision_pts.append([recall,precision])\n",
    "\n",
    "        pr_curve[i+1,0] = recall\n",
    "        pr_curve[i+1,1] = precision\n",
    "    \n",
    "    return pr_curve,np.array(precision_pts)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 1000/1000 [00:33<00:00, 29.98it/s]\n",
      "  0%|          | 248/19200000 [00:00<4:14:48, 1255.82it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "19200000\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 19200000/19200000 [00:27<00:00, 704725.78it/s]\n"
     ]
    }
   ],
   "source": [
    "pr_curve,precision_pts = mAP_fix(test_sample)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.save(\"pr_curve.npy\",pr_curve)\n",
    "np.save(\"precision_pts.npy\",precision_pts)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "pr_curve = np.load(\"pr_curve.npy\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(19200002, 2)"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pr_curve.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9940089865202196"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pr_curve[6,0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(19200002, 2)\n"
     ]
    }
   ],
   "source": [
    "print(pr_curve.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAicAAAGgCAYAAABxDccgAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAAPYQAAD2EBqD+naQAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvnQurowAAIABJREFUeJzs3XlYVNXjBvB3GHZZFBdARdHcct9Ry9LCJcU0TS1L0zRT0UxckEqz5avhlqWouaVW5q4VuWSkpUnhhvpzl0XcwJ1VQWbm98fNC5d7BxmcCzPM+3kenuace87MkQpe7z2LxmAwGEBERERkIexKewBERERE+TGcEBERkUVhOCEiIiKLwnBCREREFoXhhIiIiCwKwwkRERFZFIYTIiIisigMJ0RERGRRGE6IiIjIojCcEBERkUVhOCEiIiKLYl/aAygKvV6Pa9euwd3dHRqNprSHQ0REREVgMBiQnp6OqlWrws6u6PdDrCKcXLt2DX5+fqU9DCIiIiqGy5cvo3r16kVubxXhxN3dHYDwh/Pw8Cjl0RAREVFRpKWlwc/PT/w9XlRWEU4ePcrx8PBgOCEiIrIypk7J4IRYIiIisigMJ0RERGRRGE6IiIjIojCcEBERkUVhOCEiIiKLwnBCREREFoXhhIiIiCwKwwkRERFZFIYTIiIisigMJ0RERGRRGE6IiIjIojCcAEBGBvDKK0DTpsI/MzJKe0REREQ2yyoO/lNV27bAoUN55ZMnAXd3oE0bICam9MZFRERko0y+c/LXX3+hV69eqFq1KjQaDbZv3/7YPvv27UPLli3h5OSEOnXqYPXq1cUZq/kVDCb5HTokXCciIqISZXI4yczMRLNmzRAREVGk9gkJCejZsyc6d+6M2NhYvP/++xgxYgR2795t8mDNKiPDeDB55NAhPuIhIiIqYSY/1nnppZfw0ksvFbn90qVLUatWLcybNw8A8PTTT+PAgQP48ssv0a1bN8U+2dnZyM7OFstpaWmmDvPxBg+WFGd1GgYDgODojfDMzpS227bN/J9PREREilSfEBsdHY3AwEBJXbdu3RAdHW20z6xZs+Dp6Sl++fn5mX9gcXGS4jcB/bAsoB8iG3QstB0RERGpS/VwkpycDG9vb0mdt7c30tLScP/+fcU+YWFhSE1NFb8uX75s/oE99ZRi9QMHxyK1IyIiInVY5FJiJycneHh4SL7M7rvvJMXep/YVqR0RERGpS/Vw4uPjg5SUFEldSkoKPDw84OLiovbHG+fmJiwXLkybNkI7IiIiKjGqh5P27dsjKipKUrdnzx60b99e7Y9+vJgY4wGF+5wQERGVCpPDSUZGBmJjYxEbGwtAWCocGxuLpKQkAMJ8kSFDhojtR40ahfj4eEyZMgVnz57F4sWLsXHjRkyYMMFMf4QnFBMDpKcDftWFcpMmQpnBhIiIqFSYHE4OHz6MFi1aoEWLFgCAkJAQtGjRAtOnTwcAXL9+XQwqAFCrVi38+uuv2LNnD5o1a4Z58+ZhxYoVRpcRlwo3N+C554TXbw/noxwiIqJSZPI+J506dYLBYDB6XWn3106dOuHYsWOmfhQRERHZIItcrUNERES2i+GEiIiILArDCREREVkUhhMiIiKyKAwnREREZFEYToiIiMiiMJw8qdRU4NlngRo1hH+mppb2iIiIiKyayfucUD61agGJiXnly5eB8uWB6tWF10RERGQyhpOiyMkBFi8G4uKAp54CxowBnJyMt79yBdBogAsXgDp1Sm6cREREZQDDyeNMmQLMmwfo9Xl1RT0XqG5dIaTk70tERESF4pyTwkyZAsyZU2i40GnsMD1wFAYM+gJ6aOQNDAbAjt9mIiKiouJvTWNycoRg8hiL2/XH2lZBiPFrjNqhvyDZrSIue1SRNjIYgIsXVRooERFR2cJwYszs2ZJiYnlfhHUbi6vulXHZowqytfY4VK0hvnx2kKRdu+A1ePGdb3DHxUP6fg0bqj1iIiKiMoFzToyZMUNS7PTucgDAlsYvIsfeodCuOfYOSHarCK/7aXmVDx+ae4RERERlEu+cKLl/H9DpxGKKm5f4umAwqZxxBye+HIBnEmOlb+FQYDUP550QEREVCX9jPmIwCP88ehR45RXJpZ8aPm+020d/rIRHThbe/XcLOiYcFeuve1SSNuSKHSIioiJhOAGArVuB7T8Jr79bC+zeLbm8p047xW69Tv+Jl8/8CQB4LvEYvts4Hc4PHwAATvrUlXfQKKzmISIiIgnOOdm6FXj1VaDnRMXLd53dcaRaA0ndtrUhqJZ2E1Uy78raP3BwBgB8E9AP7ZJOoHP8EWkDjSbvLg0RERHJ2PadE50OGD9eEhYMBfYq+bN2K+jttGhwIwHx4b2QGB6EFtfPKwYTAKiWmiK+Htb/E3z5zCDIoohGwzN4iIiIjLDtcLJ/v7DVPIBk94oAgM9ffEfS5J8aTQAAzyUchZ08Zsjs+PY9SfmrZwfhYM1m8oblywPlygEZGUL55k3A21sILhqNMIG2a9e860rOnQPs7YX29vZCmYiIyMrZdji5elV8+e9/IeSRvbVbIaxbMPb7NwcAtL5yukhv6ZmdiZ2rxkrq3njtf8qxJisLcHcXwkWVKsCNG3nXDAZgzx7hetu2Ql1MTF540WiABg3yVhXpdEL50TV7e6B798LDDRERkQWy7XBy86bRS8P6f4Ifm7+Eq57eAICW184qN/z8c6BnT0nV0zcTcWDJMEldrdBI3HQtX7xxHjokBI6AgKL30emEib2Pwk/Br/79hSXTREREFsa2w0nlyorV95zdJOVad66iUpbCHBGDAfjwQyAyEqhWTXKpetpNrPvxA0ldm3HfY8Drs55szOayeTPg6gp06VLaIyEiIpKw7XDi46NY3Xz8ekm56fUL8kZOBTZZu3JFttFa+6QTGH5ou6QupkYTBL21AP6hkTiQby7KTdfy6Pp2BPxDI+EfGomvO7ymODadxg5/1mqJ2y4eSHariLf6z4B/aCQOVWuIzP9WCpnk99+FOylubkBSkun9iYiIzIxLiYug/s1EeWWtWvI6nU6yl4kGwLQ/VqBcTha+fibvDJ7/86kDAHjztf9h5eZPcLayP+Y8/5bkreZ3fBNjojdCa9AjoUJVuORmI9fOHiP6TcO5yv4AAPfsTKQ7lQMA9H9TOAtofuQ8hAQJy6JjFg2G88Ns3HD3QuWMu8i2d0CVzHvKf8jMTKBmTeG1VgucOgXUr/+Y7wwREZH5aQwGy990Iy0tDZ6enkhNTYWHh8fjOxTVjz8Cg4TQ4B8aabTZis2fIjAuRloZHg5MmSJvfP++8LhEQWGfUZKq30vG7ytGw1lXjPN+mjcH9u0DPD3NPi4iIipbivv727Yf6/j6FqlZ/VuX5JXvv6/c2MVFNkH2kcjV4wEAL16MUbz+T8Rb2LtsZKFjafLfIyZ7XS4m/7kGqzdOR9//+6PQPgVdKe+DBpO24S//Fib1AwDExgrLoL28gJwcIaj8+KPwz3znERERERWXbd85yckR544UdlcjPryXdI8TjebxZ+WUL290ozUDhNU7AFD79hWMOLQN/U/+Dge98Ms91rce+gyZL7bvFHcY5yvXwMDjv2H0P5uR5egMncYOFfOdejz25SlIqFAVS7fNRPW0G6gVGgmNQY8vdi2EARocqt4Q+2q3xu1yyiuGNn0/BW2uFm25dKEcHIAffgD69hUeDxERkc0q7u9v2w4n+/YBnTsDKDycJIYHSSsaNADOnHn8+7duDRw5onjpbKWaSHGviOfzHRZoTgYASif5PLB3RIOJWwvtu3/J29Db2aHmveQnG8TcucBE5WMBiIio7GM4KY7HzDkZevhnBEdvROWsApNIv/gCCA0t2mdkZAg7v2ZlPelozeqYbz28ku/uTGGeun0ZcRX98O4/mxH252rTP8zy/xMjIiIVcM5JcTxmzknXC9HyYAIAEyYU/TPc3ISVML16mTg4dbW4fh6J4UFIDA/CcwUPJywgrqIfAOCbdq/CPzQS/QeFI75CVaQ5umL+s28gpGcI0h1dkOHoovwGBTeAi4019x+HiIjKENu+c6LTAY6OgF6veOdk98pg+WTYyZOB2bOL93n37wth5XHzVUpJrG89TOrxPqb8uQYj+00r1nu8HrsL4w6uR9X0W0XroNEAq1cDb7zBOSpERGUMH+sUh04nLPvNyVEMJ4cXviHdGdbXF7h27ck/9+pVoG7dvO3jK1cGTpzI2xTu9GmgUSNpn+rVgXr1gKefBubMEVYFPZKaKqwQSkoCatQAVq4E2rcH7v53cnL9+sDBg8I+JsU8ayfN0RWtx/2AHHuHIrWPWTTY6MnNhTp8GGjVyvR+RERkcYr7+9u2N2Hbv19YsWNEhfvp0ooiLj1+rGrVCp+D0rChafM0PD2BAwekdXfuyNulpwvnCVWpUvT3/o9HThbOz3sFAJDh6IJNTQJR8+51NE65iMXtBmB165cl7duO/Q4VslKxd/m70Gvs4JVvZVGhWrcW/lm7tnCmkJeXyWMlIiLrZtvhJN+pxEq0hgKPX6pXV3EwJaRyZSH4nDwJNG1arLdwy7mPYUd+EcszopZhRtQyyRJpALjr6ik7CuDI14MkS6CNio8HKlYUTlfOzBQevxERkU2w7QmxKSlGL1VQOujv+edVHEwJa9JECCnZ2WZb7quB8CisMK3eWyeeH+QfGomQHhOQ+t8W/Ipyc4W9aB5NprW3Fx5PFXKiNBERWTfbnnPy4YfAzJkApEuJa9++jJ/WhsA95760fXZ22f4bvE4nPOq6dAlYtw747bcnertovyYwaIBzlf3xSeC7j23f4upZbPl+snTDu8IUZTM8IiIqNZxzUhx2yjeO4iv6yYNJp05lO5gAwmqZTp2E129JDyLEnTtAs2bC6ctF1P7ySQBAh6STGHbkF3z2wgj8XbMZEiv44oHCCcrHqjVA7VDhcdHJL/vL/x0UZDAIAeXsWR5SSERUhth2OOnQoeht335bvXFYAy8v4PJl5WvJyUWaLDztjxWSsk5jhznPDcbSdv1lbZtM2IQu56PxzbaZSHdyhevDB+L2/jINGgj/9PUFjh8X5tUQEZHVsu1w8tNPRW97+7Z647B2Pj7CXYxy5UzaCVdr0GPqn2sw9c81yNbaY1nbfpj33GDx+p567cU7KY/UunMVUctHKT/6uX49byVSbm7evimPHlddvy4EmI4duacKEZEFs+0JsYcPF70t/zb+eJmZQgBwKNpeKPk56XIxLnoDEsODCj1lOcGrGmqH/oIfmnUvfGaKvb10Em3nzsJRBZ07S69pNMKeM7NnF7qsnIiISo5thxNTVKtW2iOwDj4+wi95gyHvKzsbCA4u8lvM/3U+EsOD0OPsATS7dg4DTsgn5n7YfSxqhUYWdeps4S5eFM5KcnIChgwxxzsSEdETsO3VOoMGCYf/Qbpap1x2Fk4tGJDXztUVSEvjowBzSU0FGjc2aXItAPxbvREGvhGueK1R8kX8uuZ9c4xOsHgxMHIk/50TET0BHvxXHH5+itXlCq4S6dqVv6TMydNTmFybmwv8/jvw2mtF6hZw5RQSw4Nwfk4f2bVTPnXgHxqJMb2n4qGdFjl29jjuUxd7a7fGgmdex9iXp2BuxzdxxaNy4fuqPDJmjPD457/wSkREJce275x07w7s3g1Avs/JHytG57UbNQpYssR8n0vKmjYVdq4tgjsuHtjc5EXsrd0a0TWbFfsjK2fcwSe/f4Me5/4uvOHSpcCIEQypREQm4J0TU+l0wF9/KV5yzy5w58Ty81vZcOKEcP7Po71WCuF1Pw0jY7bhx/Uf4tDCN/Ha8d3F+sibbl4Y0ycM/qGROO5T13jDUaPkE2m1WiHgFvMwRSIiUma7S4n37887FbgA2WOdQra5JzNzcwP27pXWPeYcoMpZ9/DFroX4YtdCbG78Aq54eqPDpRNofu0cHPS50ABIdSqH85Vqou7tJKxr1h2zOw2VvU/vt74EAIyO3oTQv9Y8fqx6vXDnzd1dKA8YAKxeLT0xmoiITGa74eT6daOXyuUU2KvDx0flwVChHp0DlJEh7FNSyJ2KV40sQ/bMzkSbq6cBAGP+3Ywx/24GAGQ5OKFhyBZJ2yXt++OqZ2VM/nMt/NJuFH2cGzcKX4/06wd89x3DChGRiWz3sU4hO5qWe/hAWsGt0S2Dm5vw2Cc9HXjuObO8pevDbCSGByEhPAjvH/hBrP+5YSd0HL1KPKBwadt+uOXqiZjqjXDHpYjPTbdsEVZ69explrESEdkK250Qq9MJq3X+u4OSf0Ls8EPbpVutZ2Xxb7+WKiEBqF3bbG+3q157jHrlwyK337tsJGrdvVa0xl5ewKlTvBNHRDaDE2JNpdUKkxwVvPd3geWj//5bAgOiYqlVS3jkY8puv4Xofj4aieFBOD2/H6bu/fax7TuPXCbeXdnS6IXCG9+5I9yx02iA06fNMl4iorLIduecAMK25Qo8szOlFYXMTyEL0apV0VZV5eQAX38NrF1b6LJl14fZGBWzBaNihPko6Y4uuFWuAlLcvDCt62hcqFRT1mdiUAgmBoUAABb+FI5eZ/cbH0ejRtIy56cQEYls97EOAOzbJ5y1AuljncTwIGm7vXuLtLyVrNCdO0CdOsDduyZ3velaHm3GfV9omwtzehs/TVmJjw8QH8+QQkRlQnF/f9v2nZOOHYHq1YGrV5WvazTC9Y4dS3ZcVHK8vISAsnWrcPfCBJWz7olB9oG9I4751sfUl8bhUoWqYpu6k/NOvu5x9gAmHPgBdW9fNv6mycnCJNouXYDf5GcKERHZAtudcwII806++kr5mkYj/HPBAu4Kagv69hW201+x4vFtFTjn5qD95ZP4c9lIfLP1c8U2Oxo8iy4jlmBVq5dhAAo/tHDPHuG/wQkTeFoyEdmcYoWTiIgI+Pv7w9nZGQEBAYiJiSm0/YIFC1C/fn24uLjAz88PEyZMwIMHDwrtU2L69gU2b5bXV68u1PftW/JjotKh1QLDhwtzV3JzhcP/iqHbhX+QGB6E/+1ahMAL8snUnwaORK3QSNT6byLt0Fdn4L69k/KbLVggnJY8cmSxxkJEZI1MnnOyYcMGDBkyBEuXLkVAQAAWLFiATZs24dy5c6hSpYqs/bp16/D2229j1apV6NChA86fP4+hQ4fitddew/z584v0marNOcnHf+qvAABfBz2iX3QXHuXwjgkVlJQE1JRPhi2KNwd+hgP+LYxeb3AjAbu+HVf4m3BZOxFZkeL+/jY5nAQEBKBNmzZYtGgRAECv18PPzw/jxo3D1KlTZe3Hjh2LM2fOICoqSqybOHEi/v33Xxw4cEDxM7Kzs5GdnS2W09LS4OfnVyLhpFp5F/w99TFLQokA4XHLBx8A8+aZ1O2ypze2NeqM6+4V8WPzl2TXDy98A5WyUo2/QffuwM6dpo6WiKjElcg+Jzk5OThy5AgCAwPz3sDODoGBgYiOjlbs06FDBxw5ckR89BMfH48dO3agR48eRj9n1qxZ8PT0FL/8/PxMGWax+Hg4AwA61a+s+mdRGeHoCMydKzwGevT1aK5SIfxSU/DewfWYtTsCieFB2PhDqOR663E/wD80EqP7hCm/wa5dgJ1tTxcjorLNpJ9wt27dgk6ng7e3t6Te29sbycnJin0GDRqETz/9FM8++ywcHBzw1FNPoVOnTvjggw+Mfk5YWBhSU1PFr8uXC1ndYCbbg5/BZ30a48OeT6v+WVSG6fXAhQsmdWl75RQiV4+X1e+s/wzqTdym3OlREOJkWSIqg1T/69e+ffswc+ZMLF68GEePHsXWrVvx66+/4rPPPjPax8nJCR4eHpIvtfl4OmNwu5pwdbTt1dVkBnXq5N1JuXSpSF0ap8QhMTwI32z9HBXyPdLJsXeAf2gk6k3cqry6x8lJCCkXL5pn7EREFsCkcFKpUiVotVqkpKRI6lNSUuBj5LyQadOmYfDgwRgxYgSaNGmCV155BTNnzsSsWbOg1+uLP3Iia1CjhhBS0tOB559/bPNuF/7BsYVv4Ow86SqxHHtH1Mq3UaBM3bpFeqRERGQNTAonjo6OaNWqlWRyq16vR1RUFNq3b6/YJysrC3YFno9r/1sFYwWb0xKZh5ubsCNx/vkpJ04Ybe6cm4O42S/jvb/XSer9QyNxunIt45/DgEJEZYDJj3VCQkKwfPlyrFmzBmfOnMHo0aORmZmJYcOGAQCGDBmCsLC8iXy9evXCkiVLsH79eiQkJGDPnj2YNm0aevXqJYYUIpvUpIkQUpydFS9rDXqEHFiHhALHKfR4eyH8QyOR5uiq/L4MKERk5UyeYDFw4EDcvHkT06dPR3JyMpo3b45du3aJk2STkpIkd0o++ugjaDQafPTRR7h69SoqV66MXr164X//+5/5/hRE1uz+fWHb+ho1gIcPZZc1AA4tfFN2jk/TCRsBAHGzX4bWUOARqUYjnNFTq5C7LEREFsq2D/4jskRarbDqR0F8hap4YeQyWb3ssMr8Tp0CGjY01+iIiIqsRPY5IaISoNMBS5cqXqp99xoSw4MQs+hNSX2rsYWcjtyoER/1EJFVYTghskTvviuc72NElcx7OL5goFi+Xa48/AtbzQMIAcXBgcuOicjiMZwQWSqtVpgwa4RndiZOftlfUuf/32GClz3k51wBEALPo2XH3MCNiCwUwwmRpStk2bF7zn3sX/K2rL7j6FXwD43EdfeKxt/XyQkYO9ZcoyQiMhtOiCWyJidPAk2byqr10OCAf3MMGSjfeXla1DI0u34BLa6dk6/qAYQ7NIU8QiIiKq4SO5W4NDCcEBVQyATXv2s2wxuvKS/V/33FKNS5fUW5o+X/KCAiK8PVOkS2pJAg8cyl40gMD8ILF2Nk1wJHLMUJnzrKHbmih4gsBO+cEFkzB4ciPZLpMfQrnPZ+SlJ34ssB8MjJkjd2dwfOnAGqVTPXKInIRvHOCZEteviwSCcf71g9Hp/tjpDUNZ2wETddy8sbp6cD1avzTgoRlRqGEyJr9+jk4xs3Cm02OHYnZuyRbu7WZtz3OFq1vvFODChEVAoYTojKisqVhZBSyHk6Q49GIjE8CB0Sj4t1fQfPQ5fhEcjWGjlqiwGFiEoYwwlRWRMfD9y7Bzz9tNEm6zZ8iPaX8gLKhUo1UX/SdrQJXqvcoVIlYVt9IqISwHBCVBZ5egKnTwt3UlavVmzy4/oP8b9diyR1N928UHfSNtxzdpM2vn0bsLcHvvpKpQETEeXhah0iW7B1K9Cvn9HLsb710GfIfLHc5vIpbFoXavz9LP/HBhFZAK7WISLj+vYVlhy7uChebn79PGIWDRbLh/waYXzQJOTYcR4KEZU8hhMiW6HVAllZwLhxiperZN7F4YVviOWfGnVCvcnbMab3VCjeJ9FogGbNgNRUdcZLRDaL4YTI1nz9NZCdrXipUlYqVm+cLqnb0eBZ1AqNxFX3yvIOJ04A5csDTz0lv0ZEVEwMJ0S2yNFRmDfy77+yS50SjiIxPAhzf50vqX9mzLdIcfNSfr/4eMDHR42REpENYjghsmVt2xrd/v7V//sDieFB8L9zTawLCF6LrY06K79XSoqwoichQY2REpENYTghsnVaLbBli9HL+5aPROe4Q2I5JGgi/EMj8VWH1+SNdTqgdm1hPkpOjhqjJSIbwHBCRMJqnkICyrebP0HbpJOSui87vonBAz41/p5OTsCUKeYaIRHZEIYTIhI8Wm68aJHi5Y0/hiEhPAijozeJdftrtcRb/WcYf885cxhQiMhk3ISNiJRVrAjcuaN46ZhvPbwyZL6sPmL7LPQ897e8Q1aW0T1WiKjs4iZsRGRet28DPXsqXmpx/TwiV4+X1Qf3CcNzI5fLO7i6AkuWmHuERFRGMZwQkXGRkcCGDYqXGqfE4fiCgZiw/3tJfVIFX7zb5wN5hzFjhImy9++rMVIiKkMYToiocAMGCHNRvv5adskzOxPjD65HYngQ9i8dLtbvrt8Bx3zrKb+fqyvQq5daoyWiMoDhhIgeT6sVtr0vZEWPX2oKFv30hVh+Zch8+IdG4mLF6vLGkZFAhQpqjJSIygCGEyIquscsOQ46ewAf/rFSUhc4Yqny2Tz37gEODuYdHxGVCQwnRGSaR0uOFy9WvPzOoW1Yuu1/krpaoZGY1/FNeePcXOFsHiKifBhOiMh0Wi0werRwPk/37rLL3c9HIzE8SFK3sMNr6D8oXP5eqalAcrJaIyUiK8RwQkRPZudO4OWXFS8lhgdh5eZPxPIhv0YYMOgLeUNfX2DrVrVGSERWhuGEiJ7cTz8B69YpXnox7hD+iXhLLMf4NcZ3LXrIG/brx4BCRAAYTojIXF5/3ehkWZ+M2/i/L/uL5Wldx2BFmz7yhv36Gd2VlohsB8MJEZnPo8myClvVu+XcR+S374nlz18Ygd1128nfo2JFoE4dNUdJRBaO4YSIzEurFc7SuXFDdqnxjXh8s/Vzsfxu349w1b2y/D3i4hhQiGwYwwkRqaNyZSA7W1bd7cI/eD12l1h+Zsy3SHHzkvePixNW8hCRzWE4ISL1ODoCkyfLqmftXoR6Ny+J5YDgtcpzULgHCpFNYjghInXNnq0YUH5bFYzBRyPF8ucvjEC6o3yuCuz4Y4rI1vD/eiJS3+zZwPXrsurP9iyV7IPSZMIm5GoK/FgyGIAlS9QeIRFZEIYTIioZPj6Al3xuyYtxhyTlOlN+lvcdMwbQ6dQaGRFZGIYTIio5t28rPqZJKLDV/cxOw+R97e3VGhURWRiGEyIqWTodUKOGpEoDSM7iWRbQT/54BwA0GiA2VuUBElFpYzghopJ36RLw/POy6sXbZ4mvFR/vAECLFkJIIaIyi+GEiErHvn2yqh7n/paU/UMjoYeRIMKAQlRmMZwQUekxGGRV+c/gAYDaob8Y78+AQlQmMZwQUem6fVtSdMu5L5sg6x8aCf/QSJyuXEveX6tVc3REVAoYToiodHl5Aa6ukioNgNPz+8ma9nh7oXyjNr0e8PRUcYBEVNIYToio9GVmyqpcH2YjbvbL2PL9JEl997cj5P3T0oA1a9QaHRGVMIYTIrIMCvNPtAY9Wl09K1lmfNWzCmYp7YMydCg3aiMqIxhOiMhyKASUR6IXvyWNwG0sAAAgAElEQVS+/iagHw7WaCpvxI3aiMoEhhMisixGAopv+m2s+/EDsTzo9ZnYXbedvKFGA+TkqDU6IioBDCdEZHkMBuDsWVl1h6QTGPXPJrH8bt+P8H9Vasv7OzkBISFqjpCIVMRwQkSWqX59xbsoU/9cg3EH14vloGFfK/f/8kthN1kisjoMJ0Rk2RQCysT936Pm3Wti2T80Ur7EGBDO4SlXTs3REZEKGE6IyPLl5sqq/lw2UlJuMmETNjTtIu+blcWdZImsTLHCSUREBPz9/eHs7IyAgADExMQU2v7evXsIDg6Gr68vnJycUK9ePezYsaNYAyYiG6TVAuvWyarjZr8sKYe+NB5fPjPI+HsQkVUwOZxs2LABISEh+Pjjj3H06FE0a9YM3bp1w40bNxTb5+TkoEuXLkhMTMTmzZtx7tw5LF++HNWqVXviwRORDXn9daBJE0mV1qBHYngQvtiZN+/kq2cHwT80EjpNgR9ver0wUZaILJ7GYChkYwEFAQEBaNOmDRYtWgQA0Ov18PPzw7hx4zB16lRZ+6VLl2LOnDk4e/YsHBwcijXItLQ0eHp6IjU1FR4eHsV6DyIqI4w8otlbuzWG9Z8hlptcv4Bf1k6QN9RqFR8TEZH5Fff3t0l3TnJycnDkyBEEBgbmvYGdHQIDAxEdHa3Y5+eff0b79u0RHBwMb29vNG7cGDNnzoSukJ0cs7OzkZaWJvkiIgJgdB+UzvGHcXDxULF80rcuXhixVN5Qp+McFCILZ1I4uXXrFnQ6Hby9vSX13t7eSE5OVuwTHx+PzZs3Q6fTYceOHZg2bRrmzZuHzz//3OjnzJo1C56enuKXn5+fKcMkorLOYAAqV5ZVV02/hWNfvS6W4ytWx1v57qZI2HE9AJGlUv3/Tr1ejypVqmDZsmVo1aoVBg4ciA8//BBLlyr8jeY/YWFhSE1NFb8uX76s9jCJyNrcuAHcvi2rrvAgHb+tHCOW/6zdGv6hkdCjwN0SgwFYskTtURJRMZgUTipVqgStVouUlBRJfUpKCnx8fBT7+Pr6ol69etDmmyn/9NNPIzk5GTlGtph2cnKCh4eH5IuISMbLS/ExT71bSfgn4i1JXe3QXyBrOWYMDwskskAmhRNHR0e0atUKUVFRYp1er0dUVBTat2+v2OeZZ57BxYsXodfrxbrz58/D19cXjo6OxRw2EVE+CgHFJ+M2jnwtXVb8v87D5X0rVlRrVERUTCY/1gkJCcHy5cuxZs0anDlzBqNHj0ZmZiaGDROOMB8yZAjCwsLE9qNHj8adO3cwfvx4nD9/Hr/++itmzpyJ4OBg8/0piIgUAkrF+2lIDA8SyyvaviLvl5oK3Lmj5siIyEQmh5OBAwdi7ty5mD59Opo3b47Y2Fjs2rVLnCSblJSE69evi+39/Pywe/duHDp0CE2bNsV7772H8ePHKy47JiJ6IkZW8nz8+zfi6xF9P5I34N0TIoti8j4npYH7nBCRSQosFTYAqBUaKZZ3rwxG/VuXpH0cHYHs7BIYHJHtKJF9ToiIrEKBv3NpABzNN/+k2/AIZDo4S/vk5AArV5bA4IjocRhOiKhsunJFUvS6n4a+//eHWG4Uslm+emfECK7eIbIADCdEVDYpnN8179f5kvLEniHyfvXrqzUiIioihhMiKrvS0yVFDSBZvbO18QvyPnFxQEaGygMjosIwnBBR2eXmBjRtKque9Nda8XVYN4VtDdzd1RwVET0GwwkRlW3Hj8uqxkZvFF//2PwlXKiocH7XqFFqjoqICsFwQkRln8KOCX8tzdsttsuIJfLJsd98I6zgIaISx3BCRLbhknRfkxqpKRh6+GexPKLfdHkfJye1R0VEChhOiMg21Kghq5oRtUx8HVWnLU741JH3K7ChGxGpj+GEiGxHbq6sav+St8XXL7+1AOcryUMMKlVSc1REVADDCRHZDq0WWLFCUuWXdgNBZ/4Sy12HL8a5SjWl/W7f5uGARCWI4YSIbMvw4bKqRT/PxoATv4nlbsMj5P14OCBRiWE4ISLbo7B6Z/bOr+F/55pY/q5FD3m/pCQ1R0VE/2E4ISLbVGD3WAD4beUY8fW0rmNk11GzpryOiMyO4YSIbJObG9CmjaTKUZ+L147vFsvjek2W9+PqHSLVMZwQke2KiQGeflpS9cWuheLrXxo+jzsuHvJ+I0aoPTIim8ZwQkS27fRpWVXkt++Jr1u+tw4PtA7SBitXcvdYIhUxnBARXb8uKTa+EQ+PB3knE0/sOUHeh7vHEqmG4YSIyMdHVnVk4Rvi61+ffg4HazSR9/P3V3FQRLaL4YSICADu3ZMUHfQ6LPrpC7E86PVZ8j6XLgE//KD2yIhsDsMJEREAeHrKzt8JOnsAdW/lHRgY/txb8n5vvgnodGqPjsimMJwQET1S4ORiANizMlh8vaR9f6xv2lXeb906NUdFZHMYToiI8lM4HHDvspHi66kvvQedpsCPziFD1B4VkU1hOCEiyk+rBVatklTVunsNYXvz6jY3eVHe7+ZNtUdGZDMYToiICho2TFb1bsxW8XXoS+PlfapUUXNERDaF4YSISInC4YBtLp8SX1+o6Cfv4+qq5oiIbAbDCRGRMbdvS4rfbfhIfN1lxBLI4sv9+0BysvrjIirjGE6IiIzx8pIUnXUP8dK5v8Vy0/c3yPv4+qo9KqIyj+GEiKgwQ4dKiku2523Glu5UDrdcPeV9eHIx0RNhOCEiKszixbKquNkvi69bjzOyQywDClGxMZwQERXGxQXo3l1SpTXo4Z2eNx/FPzQSOXb28r6BgWqPjqhMYjghInqcnTtlVf8slm5lX2/ydnm/qChhkiwRmYThhIioKLKyJEUNgIv5Hu8AwBsDP5f34/JiIpMxnBARFYWLC9BVeq6OvUGPxPAgsfy3f3Osa9ZN3jciQu3REZUpDCdEREW1e7di9S+r83aM/aD7ONy3d5I2GDuWJxcTmYDhhIjIFAo7xzZJiUPfk1FieVrXUfJ+9goTZolIEcMJEZGpFALK/B1fiq83N+ki3z0W4PJioiJiOCEiKo7cXFnVN1vzJsQ2eX+jcj9PhU3biEiC4YSIqDi0WmDtWklVtwv/iK8znFzhHxopv4OSlgbcvKn++IisGMMJEVFxDR4sqzo7r6+kXEspoFSpot6YiMoAhhMioidR4ORi59wcyfJiANjWqLO837hxao6KyKoxnBARPQkvL8WN1hLyBZSQoInyfosWAZs3qzkyIqvFcEJE9KQyM2VVGgDPJh4Ty6P7hMn79e/P/U+IFDCcEBGZg8Ly4rUbpouvd9Z/BuubdpW1wUYjq3qIbBjDCRGRuRRYXmwHA7avDRHLU196T95n0CC1R0VkdRhOiIjMRasV5pLk0/z6eUzZt1osb2wSKO9XqZLKAyOyLgwnRETmFBwsqxrzb97E1yk93sc9Zzdpg9u3gTt31B4ZkdVgOCEiMjfF+SfTxNfNx6+X96lYUc0REVkVhhMiIjVcvy4pPpdv5Q4A7KzXQd6HZ+8QAWA4ISJSh4+PrOrs3FfE16Nf+QC/P9VW3s+OP5aJ+H8BEZFasrIkRWfdQ/Q7+btYHvHq9II9hEdCLVqoPTIii8ZwQkSkFhcXoHp1SdW8HQvwTsxWsdz5nW/k/WJjgYwMtUdHZLEYToiI1HT+vKzqw72rxNcJXtUQ2eBZeb9nFeqIbATDCRGRmlxcgN69ZdXHFwwUX4/tPRUP7bQFGhzn1vZksxhOiIjUtn070KWLpMozOxPfbvpYLA8YFC7v5+Cg9siILFKxwklERAT8/f3h7OyMgIAAxMTEFKnf+vXrodFo0KdPn+J8LBGR9frtN1lV5/gj4utj1RrgrrO7tIHBACQkqD0yIotjcjjZsGEDQkJC8PHHH+Po0aNo1qwZunXrhhs3bhTaLzExEZMmTULHjh2LPVgiIqumsDnbN1s/F1+3GP8jZC1q11Z3TEQWyORwMn/+fLzzzjsYNmwYGjZsiKVLl8LV1RWrVq0y2ken0+GNN97AJ598gtr8H42IbFl6uqTY7cI/ePFi3t3nnxp2kvfh5mxkY0wKJzk5OThy5AgCA/MOrrKzs0NgYCCio6ON9vv0009RpUoVDB8+vEifk52djbS0NMkXEVGZ4OYGlCsnqVq55VPx9fu9JiGxvK+8HzdnIxti0n/tt27dgk6ng7e3t6Te29sbycnJin0OHDiAlStXYvny5UX+nFmzZsHT01P88vPzM2WYRESWTeHn5eLts8TXnd5V+HlpMACenmqOishiqBrF09PTMXjwYCxfvhyVTDgSPCwsDKmpqeLX5cuXVRwlEVEJc3MDmjaVVPU49ze6nTsolv1DI+X90tKANWvUHh1RqTMpnFSqVAlarRYpKSmS+pSUFPgonCMRFxeHxMRE9OrVC/b29rC3t8fatWvx888/w97eHnFxcYqf4+TkBA8PD8kXEVGZcvy4rGpJvrsnABDSM0Teb+hQ7n9CZZ5J4cTR0RGtWrVCVFSUWKfX6xEVFYX27dvL2jdo0AAnT55EbGys+PXyyy+jc+fOiI2N5eMaIrJt2dmSoh0MODX/VbG8tfELOFijacFeQJs2ao+MqFSZ/FgnJCQEy5cvx5o1a3DmzBmMHj0amZmZGDZsGABgyJAhCAsLAwA4OzujcePGkq/y5cvD3d0djRs3hqOjo3n/NERE1sTREfjvZ+cj5R4+QNzsl8XyoNdnyvsdOwbcv6/26IhKjcnhZODAgZg7dy6mT5+O5s2bIzY2Frt27RInySYlJeH69etmHygRUZmksA2D1qDH57sjxHJEu/7yfq6uao6KqFRpDAaFXYEsTFpaGjw9PZGamsr5J0RUNinsZZJ/Uuy/EUPgnXFH2qBiReDWLbVHRlRsxf39zYXzRESWQOHviVHL3xVfBwSvxT1nN2mD27eBOwUCC1EZwHBCRGQpbt+WFJ+6cxV9T+YtQGg+fr28T8WKao+KqMQxnBARWQovL9lJxPN3fCkp/9JA4Xwybm9PZQzDCRGRJcnIkFVdmNNbfD2udyhiqjeS9xsxQs1REZUohhMiIkvi6AiMHy+pctDrsDzf+TsD3giHHgXulqxcCeTklMQIiVTHcEJEZGkWLAAK7Lrd5WIMhh/aLpZXt+ol7zdTYU8UIivEpcRERJbqMcuLE8OD5H0s/0c62RAuJSYiKmsKbG8PQPJ450JFhSNAnJ3VHBFRiWA4ISKyVI6OQHCwpCrwYoz4usuIJfI+2dlAy5Zqj4xIVQwnRESWbNEiSVEDYHT0JrGc/zGP6NgxYOJElQdGpB6GEyIiS1dgmXDoX2sk5QM1m8n7zJ/P1TtktRhOiIgs3ddfy6oS8k2GffO1/+H/qtSW93NyUnNURKphOCEisnQuLkD37pIqDYDZO74Sy0HDvkaym8JW9vb2Kg+OyPwYToiIrMHOnbKqASf3YOS/W8Ryu+A1SHd0kTbS6YAxY9QeHZFZMZwQEVkLhT1MPtj3LYLO/CWWm0zYJGuDJUs4/4SsCsMJEZE1UQgoi36eDY8HeWfyTHnpPXk/d3c1R0VkVgwnRETWJj1dVnX8q9fE1xubdkW2tsBck5wc4OZNtUdGZBYMJ0RE1sbNDWjVSlKlAbBrZd6GbW+/OkPez9tb3XERmQnDCRGRNTp8WPaopsGtS+Lrv/2by7e3NxiAO3dKYnRET4ThhIjIWqWlyariw/NOK57cY7y8T0WF5cZEFobhhIjImt27JynawYDXju8GAMRWbYCLXtXlfZo2LYmRERUbwwkRkTXz9AS8vCRVYXtXia8D31kKnabAj/qTJ3n2Dlk0hhMiImt344ak6JmdiU5xh8Xye70myfvw7B2yYAwnRETWTqsFJkyQVK3ePEN8/evTz2Fv7VaQcXGR1xFZAIYTIqKyYM4cWdWW7/PumAzr/4m8j14PtGyp5qiIioXhhIioLNBqgbVrJVWtrp7Fu/nO3vEPjZT3O3YMyMiQ1xOVIoYTIqKyYvBgwMlJUhW6b7Wk/MKIpfJ+3NqeLAzDCRFRWfLggaRoBwOOfj1ILMdXrI6//FvI+2k0ao+MqMgYToiIypoLFyRFr/tpOLh4qFgeMvAzPLB3lPdjQCELwXBCRFTW1Kkjq6qafgvBBzeI5QYTt+KOi4e8r7+/igMjKhqGEyKisshgkFVN3v+dpNzyvXXyfpcuAampao2KqEgYToiIyiqFgJIYHiQpK67gKbDjLFFJYzghIirLCpy9AwAJBQLK6cq1pA30euDmTTVHRVQohhMiorLM01M2j0QDIPar18Ryj7cXyvtVqaLuuIgKwXBCRFTWJSQAdtIf9+UfZKDBjQSxfFtpcqyjwooeohLAcEJEZAt0OlnVzm/Hia9bvbcOlz0K3C15+BC4elXtkRHJMJwQEdmKrCxJUQMgIOmkWO42PELep3p1lQdFJMdwQkRkK1xcgHLlJFUbfgxDt3MHAQBZji646KUQRri0mEoYwwkRkS1JSpJVLd0+U3z9bt8P5X3Kl1dzREQyDCdERLbEywvw9pZU5d+0Pq6iH45UbSDvl5AgryNSCcMJEZGtSU4GnJ0lVfmXFvcbPBey7dtq11Z/XET/YTghIrJFBeaRlH+QgUU/fSGWtzR+Qd7HQ2G5MZEKGE6IiGyRoyPQpYukKujsAfH1pJ4hyHSQ3l1BejqwZk1JjI5sHMMJEZGt2rlTVjX4aN5ZO41CNsv7DB2quGcKkTkxnBAR2SqtFggNlVR9tmeppLympfQcHgDApElqjooIGoNB4dhKC5OWlgZPT0+kpqbCg888iYjMR6cD7O2lVRo7PDXlZ7GcEB4kWdEDAMjNFcINUSGK+/ubd06IiGyZVgusXi2tMujx1c9zxPLPTz8v77dZ4ZEPkZnwzgkREQl3TwrMJfEPzZt/khiu8HjH8n99UCnjnRMiIiq+3FxZVf8Te8TXu+u2k/fRyB72EJkFwwkREQlu3JAU5+z8Snz9bt+PsL1hJ3kfBhRSAcMJEREJKleWVS34Za74+v1ek7BaafWOp6eaoyIbxHBCRER5rlyRFPuc3oeFP4WL5RldRsn7pKUBN2+qPTKyIQwnRESUp1o1WVWvs/sxde+3Ynl4v+nyflWqqDkqsjEMJ0REJJWdLasaFbNFfB1Vpy321Wop77d8uZqjIhvCcEJERFKOjsDkybLq+PBe4uuhAz6V9xs5klvbk1kUK5xERETA398fzs7OCAgIQExMjNG2y5cvR8eOHVGhQgVUqFABgYGBhbYnIiILMHs2MHy4pMoOBkz+M+/gv4M1msj7Fdhtlqg4TA4nGzZsQEhICD7++GMcPXoUzZo1Q7du3XCjwBK0R/bt24fXX38de/fuRXR0NPz8/NC1a1dcvXr1iQdPREQqWrFCVhX8zybx9aDXZ0FxG7aLF9UbE9kEk3eIDQgIQJs2bbBo0SIAgF6vh5+fH8aNG4epU6c+tr9Op0OFChWwaNEiDBkypEifyR1iiYhKUYG9TN7uNx1/1GkLAHDQPcSFua/I+3D3WEIJ7RCbk5ODI0eOIDAwMO8N7OwQGBiI6OjoIr1HVlYWHj58CC8vL6NtsrOzkZaWJvkiIqJSUmB58aotefNNHmod8HWH1+R9uDkbPQGTwsmtW7eg0+ng7e0tqff29kZycnKR3iM0NBRVq1aVBJyCZs2aBU9PT/HLz8/PlGESEZE5KSwvTsh31s78jm8i3dFF3o+bs1ExlehqnS+++ALr16/Htm3b4OzsbLRdWFgYUlNTxa/Lly+X4CiJiEjm3j1JUQMgYvsssdxkwibct3eS9klLA9asAZGpTAonlSpVglarRUpKiqQ+JSUFPj4+hfadO3cuvvjiC/z2229o2rRpoW2dnJzg4eEh+SIiolLk6QkUuIvd89zf6HsySiw/PXFLwV7A0KFcXkwmMymcODo6olWrVoiKyvuPUa/XIyoqCu3btzfab/bs2fjss8+wa9cutG7duvijJSKi0pOUJKuav+NLSXm/f3N5v0mT1BoRlVEmP9YJCQnB8uXLsWbNGpw5cwajR49GZmYmhg0bBgAYMmQIwsLCxPbh4eGYNm0aVq1aBX9/fyQnJyM5ORkZGRnm+1MQEVHJyMqSVeXfnG3wwM/lfRYs4N0TMonJ4WTgwIGYO3cupk+fjubNmyM2Nha7du0SJ8kmJSXh+vXrYvslS5YgJycHr776Knx9fcWvuXPnGvsIIiKyVC4uQPfukio7GND71D6xfKhaQ3k/bs5GJjB5n5PSwH1OiIgsTIGlwgYAtUIjxfKZef3gklvgjB53d2GSLNmMEtnnhIiICIBskzUNgK9+niOWFSfHpqfzcEAqEoYTIiIqnnyP8AGg95k/UedW3qTZhhM2FewhHA7Yq5e8nigfhhMiIioehS0k9qwcI77OcnTBv9UbyftFRgJPPaXmyMjKMZwQEVHxpadLihoAF2e/LJYHvhGOGKWAEh8PcGsJMoLhhIiIis/NDSiwsaa9QY85v+btfzLgjXAsb6NwOOCRI0BwsNojJCvE1TpERPTkFA76+78qtRE07GuxHHjhX6zY+pm8b+vWwKFDao6OSglX6xARUenJzZVVNb4RjxWb804w/r1uAFa06SPve/gw0Lu3mqMjK8NwQkRET06rBbbIlw8HxsUg9qvXxPLnL4zACZ868v4//wzcv6/mCMmKMJwQEZF59O2rGFDKP8jAt5tmiOWX31qAdc26yfu7uqo4OLImDCdERGQ+ffsqPuLpHH8Y3276WCx/0H0c4itUlfdXOFyQbA/DCRERmZdWK9tBFgA6xx/BwcVDxfILI5fJ+9asqeLAyFownBARkToUAkrV9FvoeXa/WI71rSfvp7Dyh2wLwwkREalHIaBE/BQuvu4zZD7OVlK4W8KAYtMYToiISF3Z2bKqtkknxdfdh0cgW2sv78eAYrMYToiISF2OjsAzz0iqNv4YhgEnfhPLL45YqtyXAcUmMZwQEZH6/vhDVjV7Z97usVfK+6DXkC9lbQAwoNgghhMiIlKfoyMwebKsOi7fIYEnfevCPzRSuT8Dik1hOCEiopIxezYwerSkSmvQSwIKADR6f6NyfwYUm8FwQkREJWfxYsDdXVKlNeiRGB4kljOdXPFunw+Qq1H4FcWAYhMYToiIqGSlpSlW5w8ou+t3wIA3whXbMaCUfQwnRERU8hT2PwGAhHwB5Wi1pzF4wKeK7RhQyjaGEyIiKh0KAUUD4Q6KVq8DAOyv1RLTA0cp92dAKbMYToiIqPQYuYNycU5v8fXaVkEI7h2q3F+jATIy1BgZlSKGEyIiKl1G7qAcXzBQLP/aoCP8QyOVd5J1dwdatFBxgFTSGE6IiKj0KQQUz+xMxCwaLKmrP2k7EipUlfePjeVjnjKE4YSIiCyDQkCpknkXieFBaJR8UazrPHIZbpSroPweDChlAsMJERFZDiNzUH5d8z76n9gjltuO/Q6bG7+g/B4aDZCaqsboqIQwnBARkWUxElDm7PwKU/d+K5Yn9QzBpB7jld+jfHkhpNy8qcYISWUMJ0REZHmMBJRRMVuwd9lIsby5SRcM6f+J8fepUoV3UqwQwwkREVkmIwGl1t1riPz2PbH8V+1WGNdrMnLsFFbyPFK+PFCtmrlHSCphOCEiIstlMAD+/rLqxjficeyr18XyLw2fR73J2zFg0Be45+ym/F7XrnHCrJVgOCEiIsuWkAC8/76susKDdCSEB+HFizFiXYxfYzQfvx7vB03EA62D8vtpNMDVq2qNlsxAYzAYuW9mQdLS0uDp6YnU1FR4eHiU9nCIiKg05OQATk6KlzIcXdBz6Fe4VGAPlLm/zser//eH8ffMzQW0WnOOkvIp7u9v3jkhIiLr4OhodB6KW859/LlsJM7OfUU8lwcQVvQY3foeAOztga1bzT1SekIMJ0REZF0KueHvrHuIuDm9sX/pcLHu0db3p6rUUu7Urx/w44/mHiU9AYYTIiKyPgaDcCfFCL/UFJyf00dS13PYQrQa+z10GoVffYMGAZ07m3uUVEwMJ0REZJ2ys4ErV4xedtTnIjE8CMu2fCbW3S5XHk9N+RnbGnaSd9i3T5gse/+++cdKJmE4ISIi61WtmnAX5exZo026XvwXieFBcMzNEesm9JqEOC8j+564ugIvvmjukZIJGE6IiMj61a8vhJT4eKNNzs/ri63fTRTLL77zDYb3m67c+I8/hLsozZpxd9lSwHBCRERlR61aQkgxsjy45bVzmB85TyxH1WmL50cuQ7qji/L7nTgh7C5bqZIaoyUjGE6IiKjsyc0Fli1TvNT31F78vnyUWL5UoSrajVmD3XXbGX+/27eFOymxseYeKSngJmxERFR26XTCqh69XvFyRLv+mPP8W5K6XSuD0eDWpcLf184OOH1aeJxERnETNiIiooK0WiGgjBqleDn4n034ZfV4SV334RHwD43ELw06Gn9fvR5o0EC4m3LunDlHTGA4ISIiW7BkCTB5suKlJilxSAwPwuuxOyX143qHovH7G3HCp07h7/0opMTEFN6OioyPdYiIyHYUcj7PI8d96qL3W19K6hrcSMC4g+vR49zfeOy5xosXAyNH8sweFP/3N8MJERHZnhdeAPbuLbTJ1kadERI0UVLn/PAB6t9MwqKfvoBf2o3CP6NdO2FJsouRlUA2gOGEiIjIFPfvCxuuPUbUU20wot80GApse1/v5iV8smcp2l8+WfgbaLXCTrY+Pk8yWqvEcEJERFQcNWoAly8/tlmaoys+DXwHm5t0kV3b/P1ktL565vGf1a8f8N13NnM3heGEiIiouFJTgfbtgTOPDxgPtA74/IUR+L5lT9m1lZs/wYtxh4r2mU2bAn/9BXh6mjpaq8FwQkREZA7vvAOsWPHYZgYAPzXshPd7TZJdm71jAV49GQU7FPFXrL29EIzqPGZlkJVhOCEiIjKXnBwgIKDIO8IqTZ4FgFH/bMKEAz/ASZdr2ud7eQGnTro01oAAAA0oSURBVFn9PBWGEyIiInPLyQFCQoCIiCI1j3qqDUb3+QA59g6S+mbXzuGVU3vx5rEdsDco71ZbKCsNKwwnREREakpNBSpXBh4+fGzTu87uePvVj3GsWgPZNZecB2iSchGT/1yL1ldPP37fFGOsYM4KwwkREVFJMGHyrB4abG/UCTM7vY1bbhWMtvv659nocuFfuORmm3OkykpwxRDDCRERUUk7cgRo3bpITXPs7LGhWVdsahKIE771FNvUuZWE9kknMPjYDtS9lVT8uypFpfIBhiUaTiIiIjBnzhwkJyejWbNmWLhwIdq2bWu0/aZNmzBt2jQkJiaibt26CA8PR48ePYr8eQwnRERk0UwIKY+kOpXD4nb9sbZlEO47Oiu2qZaaghfiDqFz3GE8cynW9Im1plDhXkWJhZMNGzZgyJAhWLp0KQICArBgwQJs2rQJ586dQ5UqVWTtDx48iOeeew6zZs1CUFAQ1q1bh/DwcBw9ehSNGzcu0mcynBARkVU4eVKYC2IiA4B9tVthQ9Ou2FX/mULbNk6+iJfP/IkqGXdR8+41+N+9jvIP0s1zl8XMAaXEwklAQADatGmDRYsWAQD0ej38/Pwwbtw4TJ06VdZ+4MCByMzMRGRkpFjXrl07NG/eHEuXLi3SZzKcEBGRVbl6FahevdjdH9g7IqZ6I6xr3v2xYSW/Wneuotp/Z/7karTwS02Bo+4hksr7oN6tJGj1OmgMBmgNetS8dx0DTuyRhpqzZ836iKe4v7/tTfmQnJwcHDlyBGFhYWKdnZ0dAgMDER0drdgnOjoaISEhkrpu3bph+/btRj8nOzsb2dl5k4LS0tJMGSYREVHpqlYt7y5EMe6mOOfm4LnEY3gu8RgA4c5KnFd1/FOjCQ74N8f5SjWRWMEXejvpyccJXtWQ4FVNLP+T79r+Wi1ln/P0jQQ0Tb6YV9GoEZCr4qOjIjIpnNy6dQs6nQ7e3t6Sem9vb5w9e1axT3JysmL75ORko58za9YsfPLJJ6YMjYiIyDI1aZIXVC5eBOrWNfktNADq3LmCOneu4M3YnZJrWQ5OSHariEsVqiJHa4/brp5Ic3KDg/4hsrWOuFipBnzTbkJnZwe9Rvha0fYVPJt4DPY6nfSDCpZLiUnhpKSEhYVJ7rakpaXBz8+vFEdERERkBnXq5AWVO3eE4HLt2hO9pevDbNS+ew217xb9fT7au1L5glarXF/CTAonlSpVglarRUpKiqQ+JSUFPkZ2rfPx8TGpPQA4OTnBycnJlKERERFZFy8vYW7KI0lJQM2apTceQNiF1gLYmdLY0dERrVq1QlRUlFin1+sRFRWF9u3bK/Zp3769pD0A7Nmzx2h7IiIim1SjhnBX5dHXlSslPwaV9jsxlUnhBABCQkKwfPlyrFmzBmfOnMHo0aORmZmJYcOGAQCGDBkimTA7fvx47Nq1C/PmzcPZs2cxY8YMHD58GGPHjjXfn4KIiKiseTSpNv+XkfmdZmFBe7KaPOdk4MCBuHnzJqZPn47k5GQ0b94cu3btEie9JiUlwc4uL/N06NAB69atw0cffYQPPvgAdevWxfbt24u8xwkRERH9p3794oUIYyuGVN4htri4fT0RERGpori/v01+rENERESkJoYTIiIisigMJ0RERGRRGE6IiIjIojCcEBERkUVhOCEiIiKLwnBCREREFoXhhIiIiCwKwwkRERFZFIYTIiIisigMJ0RERGRRTD74rzQ8Ov4nLS2tlEdCRERERfXo97apx/hZRThJT08HAPj5+ZXySIiIiMhU6enp8PT0LHJ7qziVWK/X49q1a3B3d4dGo1HlM9LS0uDn54fLly/z5GOV8HusPn6P1cfvsfr4PVZfSX2PDQYD0tPTUbVqVdjZFX0miVXcObGzs0P16tVL5LM8PDz4P4PK+D1WH7/H6uP3WH38HquvJL7HptwxeYQTYomIiMiiMJwQERGRRdHOmDFjRmkPwlJotVp06tQJ9vZW8bTLKvF7rD5+j9XH77H6+D1WnyV/j61iQiwRERHZDj7WISIiIovCcEJEREQWheGEiIiILArDCREREVkUhhMiIiKyKDYVTiIiIuDv7w9nZ2cEBAQgJiam0PabNm1CgwYN4OzsjCZNmmDHjh0lNFLrZcr3ePny5ejYsSMqVKiAChUqIDAw8LH/Tsj0/44fWb9+PTQaDfr06aPyCK2fqd/je/fuITg4GL6+vnByckK9evX48+IxTP0eL1iwAPXr14eLiwv8/PwwYcIEPHjwoIRGa33++usv9OrVC1WrVoVGo8H27dsf22ffvn1o2bIlnJycUKdOHaxevVr9gRpjsBHr1683ODo6GlatWmU4deqU4Z133jGUL1/ekJKSotj+77//Nmi1WsPs2bMNp0+fNnz00UcGBwcHw8mTJ0t45NbD1O/xoEGDDBEREYZjx44Zzpw5Yxg6dKjB09PTcOXKlRIeufUw9Xv8SEJCgqFatWqGjh07Gnr37l1Co7VOpn6Ps7OzDa1btzb06NHDcODAAUNCQoJh3759htjY2BIeufUw9Xv8ww8/GJycnAw//PCDISEhwbB7926Dr6+vYcKECSU8cuuxY8cOw4cffmjYunWrAYBh27ZthbaPj483uLq6GkJCQgynT582LFy40KDVag27du0qoRFL2Uw4adu2rSE4OFgs63Q6Q9X/b+/+Qprq4zCAP6/a0S4WIbI5QYMNorAiMJJpIIUgFHWpUIxdJBraVVBJEousNUK6if5QinWVRBSEilSrLkq90Q2ClmGjummCEDQy2Oa+78WL451O6pz33dk57vnAbn7+Djx7mJ6vZztaVSVXrlzJur+1tVUOHTqUsVZfXy+dnZ05zWlmajteKZlMisVikfv37+cqoulp6TiZTEpDQ4MMDAyIx+PhcPIbaju+deuWOBwOicfjekU0PbUdd3d3y4EDBzLWTp06JY2NjTnNuV78yXBy5swZqa2tzVhra2uTlpaWXEZbU0G8rROPxzE9PY3m5ub0WlFREZqbmzE5OZn1mMnJyYz9ANDS0rLm/kKnpeOVFhcXkUgkUF5enquYpqa144sXL8JqteL48eN6xDQ1LR0/ffoULpcL3d3dsNls2LFjB3w+H5aWlvSKbSpaOm5oaMD09HT6rZ9IJIKxsTEcPHhQl8yFwGjnPOP9zdocWFhYwNLSEmw2W8a6zWbDhw8fsh4TjUaz7o9GoznLaWZaOl7p7NmzqKqqWvUNQv/Q0vGbN28wODiIUCikR0TT09JxJBLBy5cvcezYMYyNjWFubg5dXV1IJBLwer16xDYVLR0fPXoUCwsL2LdvH0QEyWQSJ06cwLlz5/SIXBDWOuf9+PEDv379wsaNG3XNUxBXTsj4/H4/hoeH8eTJE5SVleU7zroQi8Xgdrtx9+5dVFRU5DvOupVKpWC1WnHnzh3U1dWhra0Nvb29uH37dr6jrRuvX7+Gz+fDzZs3MTMzg8ePH2N0dBR9fX35jkY5UhBXTioqKlBcXIz5+fmM9fn5eVRWVmY9prKyUtX+Qqel42X9/f3w+/148eIFdu3alcuYpqa240+fPuHz5884fPhwei2VSgEASkpKMDs7C6fTmdvQJqPldWy327FhwwYUFxen17Zv345oNIp4PA5FUXKa2Wy0dHz+/Hm43W60t7cDAHbu3ImfP3+io6MDvb29KCri79n/1VrnvE2bNul+1QQokCsniqKgrq4OgUAgvZZKpRAIBOByubIe43K5MvYDwPPnz9fcX+i0dAwAV69eRV9fH8bHx7Fnzx49opqW2o63bduGd+/eIRQKpR9HjhzB/v37EQqFUF1drWd8U9DyOm5sbMTc3Fx68AOAjx8/wm63czDJQkvHi4uLqwaQ5WFQ+L9r/xeGO+fl5WO4eTA8PCylpaVy7949ef/+vXR0dMjmzZslGo2KiIjb7Zaenp70/rdv30pJSYn09/dLOBwWr9fLW4l/Q23Hfr9fFEWRR48eybdv39KPWCyWr6dgeGo7Xol36/ye2o6/fv0qFotFTp48KbOzszIyMiJWq1UuXbqUr6dgeGo79nq9YrFY5MGDBxKJROTZs2fidDqltbU1X0/B8GKxmASDQQkGgwJArl27JsFgUL58+SIiIj09PeJ2u9P7l28lPn36tITDYblx4wZvJdbL9evXpaamRhRFkb1798rU1FT6a01NTeLxeDL2P3z4ULZu3SqKokhtba2Mjo7qnNh81HS8ZcsWAbDq4fV69Q9uImpfx//G4eTPqO14YmJC6uvrpbS0VBwOh1y+fFmSyaTOqc1FTceJREIuXLggTqdTysrKpLq6Wrq6uuT79+95SG4Or169yvrzdblXj8cjTU1Nq47ZvXu3KIoiDodDhoaGdM+97C8RXhMjIiIi4yiIz5wQERGReXA4ISIiIkPhcEJERESGwuGEiIiIDIXDCRERERkKhxMiIiIyFA4nREREZCgcToiIiMhQOJwQERGRoXA4ISIiIkPhcEJERESG8jcOF4znS7AYLgAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib\n",
    "matplotlib.rcParams['agg.path.chunksize'] = 1920000200000000\n",
    "matplotlib.rcParams.update( matplotlib.rc_params() )\n",
    "plt.plot(pr_curve[:,0],pr_curve[:,1])\n",
    "plt.scatter(precision_pts[:,0],precision_pts[:,1],color='r')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def mAP_final(test_sample):\n",
    "       \n",
    "    epsilon = 4\n",
    "    \n",
    "    conf_list = []\n",
    "    label_list = []\n",
    "    mask_list = []\n",
    "    \n",
    "    for sample in tqdm(test_sample):\n",
    "        heatmap = list(get_heatmap(sample).reshape((-1,)))\n",
    "        \n",
    "        pts = sample['pt'].astype(int)\n",
    "        label = point2label(pts,binary=True)\n",
    "        \n",
    "        label_mask = label.copy()\n",
    "        \n",
    "        for point in pts:\n",
    "            x,y = point\n",
    "            label_mask[max(x-epsilon,0):min(x+epsilon,label.shape[0]),max(y-epsilon,0):min(y+epsilon,label.shape[1])] = 1\n",
    "        \n",
    "        label = list(label.reshape((-1,1)))\n",
    "        label_mask = list(label_mask.reshape((-1,1)))\n",
    "        \n",
    "        conf_list += heatmap\n",
    "        label_list += label\n",
    "        mask_list += label_mask\n",
    "    \n",
    "    conf_list = np.array(conf_list)\n",
    "    label = np.array(label_list)\n",
    "    label_mask = np.array(mask_list)\n",
    "    \n",
    "    index = list(reversed(np.argsort(conf_list).tolist()))\n",
    "    \n",
    "    pred_label = np.zeros_like(conf_list)\n",
    "    \n",
    "    pred_positive_sample_num = 0\n",
    "    precision_pts = []\n",
    "    pr_curve = np.zeros((len(index)+2,2))\n",
    "    \n",
    "    pr_curve[0,0] = 0\n",
    "    pr_curve[0,1] = 1\n",
    "    pr_curve[-1,0] = 1\n",
    "    pr_curve[-1,1] = 0\n",
    "    \n",
    "    TP = 0\n",
    "    positive_sample_num = np.sum(label)\n",
    "    print(len(index))\n",
    "    for i in tqdm(range(len(index))):\n",
    "        \n",
    "        ind = index[i]\n",
    "        \n",
    "        pred_label[ind] = 1\n",
    "        \n",
    "        pred_positive_sample_num += 1\n",
    "        \n",
    "        \n",
    "        if label[ind] == 1:\n",
    "            TP += 1\n",
    "        elif  label_mask[ind] == 1:\n",
    "            TP += 1\n",
    "            positive_sample_num += 1\n",
    "\n",
    "\n",
    "         \n",
    "\n",
    "        precision = TP/pred_positive_sample_num\n",
    "        recall = TP/positive_sample_num\n",
    "        \n",
    "        if recall != 0 and recall != pr_curve[i,0]:\n",
    "            precision_pts.append([recall,precision])\n",
    "\n",
    "        pr_curve[i+1,0] = recall\n",
    "        pr_curve[i+1,1] = precision\n",
    "    \n",
    "    return pr_curve,np.array(precision_pts)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 1000/1000 [00:36<00:00, 27.28it/s]\n",
      "  0%|          | 0/19200000 [00:00<?, ?it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "19200000\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 19200000/19200000 [01:04<00:00, 295486.01it/s]\n"
     ]
    }
   ],
   "source": [
    "pr_curve,precision_pts = mAP_final(test_sample)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.save(\"pr_curve.npy\",pr_curve)\n",
    "np.save(\"precision_pts.npy\",precision_pts)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib\n",
    "matplotlib.rcParams['agg.path.chunksize'] = 1920000200000000\n",
    "matplotlib.rcParams.update( matplotlib.rc_params() )\n",
    "plt.plot(pr_curve[:,0],pr_curve[:,1])\n",
    "plt.scatter(precision_pts[:,0],precision_pts[:,1],color='r')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.06039093713881635\n"
     ]
    }
   ],
   "source": [
    "print(np.mean(precision_pts[:,1]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.5441141390297709\n"
     ]
    }
   ],
   "source": [
    "precision_pts=np.array(precision_pts)\n",
    "print(np.mean(precision_pts[:,1]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def mAP_final(test_sample,mute=True):\n",
    "       \n",
    "    epsilon = 4\n",
    "    \n",
    "    conf_list = []\n",
    "    label_list = []\n",
    "    mask_list = []\n",
    "    index_map_list = []\n",
    "    \n",
    "    for sample in tqdm(test_sample):\n",
    "        \n",
    "        pts = sample['pt'].astype(int)\n",
    "        label = point2label(pts,binary=True)\n",
    "        \n",
    "        label_mask = label.copy()\n",
    "        \n",
    "        index_map = np.zeros_like(label)\n",
    "# check index map code        \n",
    "#         x = 0\n",
    "#         y = 0\n",
    "        for point in pts:\n",
    "            x,y = point\n",
    "            label_mask[max(x-epsilon,0):min(x+epsilon,label.shape[0]),max(y-epsilon,0):min(y+epsilon,label.shape[1])] = 1\n",
    "            index_map[max(x-epsilon,0):min(x+epsilon,label.shape[0]),max(y-epsilon,0):min(y+epsilon,label.shape[1])] = x*160+y+len(label_list)\n",
    "        \n",
    "        heatmap = get_heatmap(sample)\n",
    "# check index map code\n",
    "#         if pts.shape[0] !=0:\n",
    "#             try:\n",
    "#                 assert heatmap[x,y] == tmp[index_map[x-1,y-1]]\n",
    "#                 print(\"correct\")\n",
    "#             except AssertionError:\n",
    "#                 print(f\"{heatmap[x,y]}!={tmp[index_map[x-1,y-1]]},\\nwhen index_map[{x-1},{y-1}]=={index_map[x-1,y-1]}\")\n",
    "#                 print(\"where\",np.where(tmp==heatmap[x,y]))\n",
    "#                 raise\n",
    "        heatmap = list(heatmap.reshape((-1,)))\n",
    "        label = list(label.reshape((-1,)))\n",
    "        label_mask = list(label_mask.reshape((-1,)))\n",
    "        index_map = list(index_map.reshape((-1,)))\n",
    "        \n",
    "        conf_list += heatmap\n",
    "        label_list += label\n",
    "        mask_list += label_mask\n",
    "        index_map_list += index_map\n",
    "        \n",
    "\n",
    "    conf_list = np.array(conf_list)\n",
    "    label = np.array(label_list)\n",
    "    label_mask = np.array(mask_list)\n",
    "    index_map = np.array(index_map_list) \n",
    "    \n",
    "    index = list(reversed(np.argsort(conf_list).tolist()))\n",
    "    \n",
    "    if not mute:\n",
    "        print(conf_list[index])\n",
    "        print(\"*\"*20)\n",
    "        print(sorted(conf_list))\n",
    "        \n",
    "    pred_positive_sample_num = 0\n",
    "    precision_pts = []\n",
    "    pr_curve = np.zeros((len(index)+2,2))\n",
    "    \n",
    "    pr_curve[0,0] = 0\n",
    "    pr_curve[0,1] = 1\n",
    "    pr_curve[-1,0] = 1\n",
    "    pr_curve[-1,1] = 0\n",
    "    \n",
    "    TP = 0\n",
    "    positive_sample_num = np.sum(label)\n",
    "    pred_label = np.zeros_like(conf_list)\n",
    "\n",
    "    for i in tqdm(range(len(index))):\n",
    "        \n",
    "        ind = index[i]\n",
    "#         if label[ind] == 1:\n",
    "#             TP += 1\n",
    "#         elif  label_mask[ind] == 1:\n",
    "#             TP += 1\n",
    "#             positive_sample_num += 1\n",
    "\n",
    "        pred_positive_sample_num += 1\n",
    "        \n",
    "\n",
    "        if label_mask[ind] == 1:\n",
    "            origin_index = index_map_list[ind]\n",
    "            if pred_label[origin_index] == 1:\n",
    "                pred_positive_sample_num -= 1\n",
    "            else:\n",
    "                pred_label[origin_index] = 1\n",
    "                TP += 1\n",
    "\n",
    "        precision = TP/pred_positive_sample_num\n",
    "        recall = TP/positive_sample_num\n",
    "        \n",
    "        if recall != 0 and recall != pr_curve[i,0]:\n",
    "            precision_pts.append([recall,precision])\n",
    "\n",
    "        pr_curve[i+1,0] = recall\n",
    "        pr_curve[i+1,1] = precision\n",
    "    \n",
    "    return pr_curve,np.array(precision_pts)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 1000/1000 [00:33<00:00, 29.73it/s]\n",
      "100%|██████████| 19200000/19200000 [00:28<00:00, 665159.74it/s]\n"
     ]
    }
   ],
   "source": [
    "pr_curve,precision_pts = mAP_final(test_sample)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.save(\"pr_curve.npy\",pr_curve)\n",
    "np.save(\"precision_pts.npy\",precision_pts)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib\n",
    "matplotlib.rcParams['agg.path.chunksize'] = 1920000200000000\n",
    "matplotlib.rcParams.update( matplotlib.rc_params() )\n",
    "plt.plot(pr_curve[:,0],pr_curve[:,1])\n",
    "plt.scatter(precision_pts[:,0],precision_pts[:,1],color='r')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.8033742034973045"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.mean(precision_pts[:,1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAicAAAGgCAYAAABxDccgAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAAPYQAAD2EBqD+naQAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvnQurowAAIABJREFUeJzt3XlYVPX+B/D3zMAMIIsCsorivouKaWhmdikr13tvZeV1u90stxbKrUy7LZot5s/EvNlim1tWXq+aVhSVZprgLi6ICKIgiOzLwMz5/TE5cDgDzAzM4Qy8X88zz3O+3/mcMx/m3ut87jnfRSUIggAiIiIihVA3dQJERERE1bE4ISIiIkVhcUJERESKwuKEiIiIFIXFCRERESkKixMiIiJSFBYnREREpCgsToiIiEhRWJwQERGRorA4ISIiIkVhcUJERESK4tLUCVjDaDTiypUr8PLygkqlaup0iIiIyAqCIKCwsBAhISFQq62/H+IUxcmVK1cQFhbW1GkQERGRHdLT09GuXTur452iOPHy8gJg+uO8vb2bOBsiIiKyRkFBAcLCwsy/49ZyiuLk5qMcb29vFidEREROxtYhGRwQS0RERIrC4oSIiIgUhcUJERERKQqLEyIiIlIUFidERESkKCxOiIiISFFYnBAREZGisDghIiIiRWFxQkRERIrC4oSIiIgUhcUJERERKQqLEwDIzwd69QJUqsZ/+fkBmZlN/RcSERE5DafY+M+hunQBLlxw3PVzc4HgYMDVFdDrHfc5REREzYTNd05++eUXjB07FiEhIVCpVNi+fXu958THx2PgwIHQ6XTo0qULNmzYYE+ujc/RhUl1FRWmOylERERUJ5uLk+LiYkRERCA2Ntaq+IsXL2L06NEYOXIkjh49iqeffhr/+te/sHfvXpuTbVT5+fIVJtV17Cj/ZxIRETkRmx/r3Hvvvbj33nutjl+3bh06duyIt99+GwDQs2dP7Nu3D++88w5GjRpl8Zzy8nKUl5eb2wUFBbamWb/Ro0XN5SOm4YaHd6N+xMgLh3Hvud/EnamppsLIx6dRP4uIiKi5cPiYkwMHDiA6OlrUN2rUKDz99NO1nrN8+XL8+9//dmxiaWmi5u4etyG9dVCjfsTWfnfjg20vI/rCIfEbrVtLg7Va4MwZ3lkhIqIWz+HFSWZmJgIDA0V9gYGBKCgoQGlpKdzd3SXnLFq0CDExMeZ2QUEBwsLCGjex9u2B9HRzc8bBr1Coa9Uoly7WuiN26EQAwOphD0mLE0v0eqBTJ9Px+fNA165V73XtCvz+O+Dr2yj54ehRYMAA62LXrgVmzAA0msb5bCIionoocraOTqeDTqdz7Ifs2iW6gzH56LeNenmPijK8OWIqjgd3Q4VaA1ejwfqTqxcmgKlY8fNr1PysNmuW6QUALi5AUpJpIDEREZGDOHydk6CgIGRlZYn6srKy4O3tbfGuiWx8fIDOnR12+b+f/NF8vGzkP2FQqXGpdRDKNaZ60KBSI7V1MOI634Kz/h0clkejqqw0FU6NtQZMQkJT/0VERKRADr9zEhUVhd27d4v6vv/+e0RFRTn6o+uXnOyw6cRBRdfNxx8PGo8v+t8LvYsWANDv6jmc82+PMlc3c0zi6kfgW+qAgb9KNmhQ3e+rVMDJk6YF8oiIqMVQCYIg2HJCUVERkpOTAQADBgzAypUrMXLkSPj6+qJ9+/ZYtGgRMjIy8OmnnwIwTSXu06cPZs+ejX/+85/48ccf8eSTT2LXrl21ztapqaCgAD4+PsjPz4e3d+POqAFgmj0TFWV6ZNGI9nWIwD8eeq3W93UV5Sh3rXp8dXHFGGR4t8WpwM44HdAJJ4K6wKu8BBOPf4ehacdF5xqhggoCVAAqVWpk+ATgUutglGjdMCz1KDz1pchz88IVb390yMtEiasOWZ5+yPTyQ6aXPzI9/XDVyx/XvHyR3aoNzrYNx4CMMyhz0SK7VRvkeLbBzo+fROuyQviUFcFTX4omXaWFhQoRkdOx9/fb5uIkPj4eI0eOlPRPnToVGzZswLRp05Camor4+HjROc888wxOnz6Ndu3a4cUXX8S0adOs/kyHFyeNZfly4PnnRV1/hPZCeutA9Mm6gMSQHrji7Y8e2ZfQPTsV4TeuYuzUd3A6sP7HS2F5mbjWqg3KXXXoce0iUnxDoXfRIqTgGq618kWlxvHDh+b9/Al6XruIfDdPhBZkI7DoOlSCgLD8LKgA6NUuyHfzhH9JnrmQKXXRocxFizZlhQ7PD76+wKlTQFDjzroiIiL7yFacNAWnKU70esDGgbwCgI4LdprbLoZKdM1JQ9fradjR6w6rr1PzLkxNKsGItkU3EFR0HUGFplfgn8clrjrkuXsjuDAb/sV52BRxD/Z2H2rT3+Fbko9cj6q1W9wqyqAWBJRoLY8rmv3bFsw5sBXuleUW328wtRo4fRro3t0x1ycionqxOFGK+fOBN9+06ZRsj9Y4FNYbHfIy0TXnEnSGSvN7B9v1xv7w/uiYm4HjwV0RVHgdXa6nQ4AKuR4+aJ93FR3yriKwMBdqCMjXtcKZtuFoW3wDIQXZMKrVyHPzQtviGzbNGLrh5gW1YISnvhTPjImxqVCyl4uhEpUaFwQXZOOqd1ucf3O8bbOc6tOpE/DHH403JZuIiOrE4kRJ7ChQnI0RKlRoNEgI7QmjSo22xXloW3wDJa46HA3pjsDCXPiX5MG/+Aby3Txx3r8D3CvKsPyOf+JYSDebPiuw8Dq2fT4P7QquOWbcC8ezEBE5BIsTpdHrgZgYwMo9iFqapLbhqNC4INfdGxneAfArzUeWpx/a5Wfh0fuX1nqexmhAUGEOemWl4JqnL46FdEd47hUMvnwSK75d7Zji5eGHgQ8/BJpy6jsRkRNicaJ0RUXA5MmmacudOwOffQaEhgKO2DeoGTjdtiO29rsLGwaNs+k8jdEAg1qDbZ/PQ667NwKKb6BvZjI0grFxEktJ4RYDRERWYnHirLKzTWutNFWR8vTTwIoVpr19bkpIqH8NEhkZoUJSQDg+HDQBOa1ao//Vc2hblAuDWgOtoQLP3zPXquts2LoEZS469M1MRrmLKwKKb6CVvVOkLX1vREQkwuKkOSotBebNMy1f37kzMH48kJsLBAcDw4fLs99Nbi7Qty9w5YrjP8tOAoATQV2Q4R2AmX81TeX2L76BnFZtrDr/1Mr70aqirHGS4SMgIiIzFiekfAYDsG4dMGeObB95rVVrDJ7zOTz0pbVOa66u/5UzGJx+CvvC+yM0/xoGXz6NqQn/g9ZYWe+5dQoOBo4dA9q2bdh1iIicCIsTah6KioDRo4FffnHI5Qu17tAaKuBiNOL2x9cjwyew/pP+tHb7ctx3dn/jJNKvn+lv9PGpP5aIyEmxOKHmp6gIGDMG+Plnh1zeCBWOBXfFobA+ePP2KajUuODes/tx2TsAbYtv4Mcugy2eF3XpGLpcT0e5ixah+dcQmZGE2y4da7zEOJ6FiJoJFifU/FUfg9O1q2ktmexsoIPjdnXWq13Qbd52q2InJ+5En6wLcDVU4qx/B3iXF2PExUT0yWqEjSX5WIiInBCLEyIHbeB400+dBmH6Ay+hdWkB8ty90ePaRZwJqH9acZ/MZAy/eAR3XvgDt2ScbpxkuDw/ETkBFidEliQnm+6yOEipiw49n/3K3L65BL93WREK3DwtnuNXnIcHj3+PSUd3I7QgG0aVuvHWYQGA/v2B+HiOZyGiJsfihMgWDh54CwAZXm0xeeIrSPFrZ/U5T+/7ArMOfNnw2UE3rV0LzJghz7RzIqIaWJwQ2SszEwgPB8odtEMygEqVGjt73o6tfe/CwfZ9YFBbXyz0uHYR/ziyG9c8fTH+dDw652bYlwQH2hKRzFicEDmCg1bwLdO44rpHawBAroc3Ph40Hl/3udPq8w+/Own+JfmNlxDvsBCRA7A4IXK0o0eBAQMc+hGVKjVOBHXBpTYhONSuN35v3xfFWncU6jxqXUROW6mH3kULr7IidL2ejtkHtuL2i4lwNRrsT8TXFzh1CggKsv8aRNTisTghagr5+cBttwEnTzr8o/RqFzz0yHIkhva0Kj7iylms3LXS/sdANyn/nwgiUigWJ0RKc/Ei0KlTo19Wr3bBLx0H4oJfOwQW5SIpoCOS/cKwv0M/lLm61Xre6h1vYHD6KWgNFWilL4HO0MBBtxMnAh9/zH2EiKhWLE6IlO7sWaBHD4d/zM31WKz12KGvcbFNKB46thfRFw7Z/8EqlekOUq9e9l+DiJoVFidEzswB41mMUOG7rrdi2ch/Iq1NsE3npqwYCzUa+E8DB9kStXgsToiaE4MB2LgRmDKl0S5ZrnGBq8GAEq0bzvuF4eW/zECeuxcMKrXF4mX2b1vgX5KHfDdPzPltC1waslAcV7QlapFYnBA1dw5cnr9CrcE3vUdi/n1P1xnnoS9FidYd3bNT8e6ON9AtJ832Dzt8GIiMtDNTInImLE6IWqrSUmDyZOCrr+qPtcKCe+ZiS8QoDMxIsnpmEGAacDsuyc4Vdz/+2PQ38BEQUbPC4oSITBISgEGDGuVSAoBTAZ2wL3wAvMuL8MEtE5DiF1bveSMv/IGRFw7jr6d+hJe+1PoPXL0amDvX/oSJSFFYnBCR1IkTQL9+Drn0Ze+2uOAXhkX3zMEV74C603jnAduKlJvc3YEzZ4D27e3MkoiaEosTIrJNI99hORrcDT93isSHg8ajsJYdme8/8T16ZF9ChxtXcEdKgm2r2P7978Bnn3FdFSInwuKEiBrmP/8Bnnii0S6Xr2uF8VPeQapvSJ1xAzOSsGnTItsWhTt/3rTnEREpmr2/32oH5kREzuTxx4HKSmDNmka5nE95MeLXz0Di6kcQff4gfGvZqDAxtCe6P7cdu7sPs/7iXbuaFn1Ls2O2EBEpHu+cEJF1SkuBSZOAb75p8KVKXHV46OHlOB7crdYYn9JCbNr0PHplX7TuopyiTKQ4fKxDRPIrKgJGjwZ+sW8KsUGlxqzxC7G3+9A648LyMrH3o9nwqCiv/6KurqaxKfffz6nJRE2MxQkRNb0GDLJNbR2MtNZBOBTWG59EjkWhrpXFuPVfvYy7km3YA4h3VIiaDIsTIlKW/Hygd28gI8PuS3w6YDSW3D3T4ntP/P4lwm9cxUPHv7P+gt7ewPz5wLx5gFZrd15EZB0WJ0SkTAYDsG4dMGeO3ZdI9m2H6MfW1fr+k/s3ImbfRtsvfOQI0L+/3XkRUd1YnBCR8ygqAtq2BcrKbDrNoFKj8/wddcYMSTuBRfEfo09msm2bFXIdFaJGx+KEiJxPAzczfOP2KVgb9WCt78/7+RPM/v1L2y46ciTw44925UNEYixOiKh5yMw0LVdfUWH1KT92GoRF98xFlpefxfdblZegWOeBDVuXICrtuPULvnEwLVGDsDghoubHzr2BtvS7CwvufarOmAXxH8OvJB8Pnvih/gtybAqRXVicEFHzlZsL+Fm+K1KX38P64OeOkdjb7dY6d1O+9+x+vPvfFfWPUTl1CujVy+Y8iFoqFidE1PxlZgIdOgB6vc2nCgDKXHTYFDEKX/aNRlJgJ0nMB9teRvQFK9ZQKS/nVGQiK7A4IaKWpYFTlAUAW/rdjYX3Pmnx/dFnfsWa/66AypqLubiYBvVyM0IiERYnRNRyNeCOCgB8MGg8Xv3LYxbf+/qzZzHwylnbLtivn2lJfx8fu/Ihai5YnBARAQ26o3Ld3RufDRyNVbdNkrx3aM0/EFCcZ3s+ly6ZZh8RtUAsToiILElOBrp2tfm0ZXdMx/tD/i7qi7x8Gv0yz+MvyYdw26Vjtufi7Q2cPg2Ehtp+LpETYnFCRFQfvR6IiQFiY60LV7ug/1ObUKK1vGqsh74UGsGIHZ88g443rtiWS14eH/tQs8fihIjIVn37AidP1huWGNIdS6OfQLHWrc4pyQDw4PHvsHzPGmisXTp/7VpgxgxAo7EunsiJsDghIrJHUREwerRpAKuVMj398G33oYi99UHkeLapNW5+/AZMT/gf3CvLrbtwcDBw7Jhp3yGiZoDFCRFRQxkMwKhRQFycTadd8fLHpwNHY92tD9QaM/b0z5h7YAu65aRZd9HCQsDT06Y8iJSGxQkRUWPR64Hu3YHUVJtPPevfAU+PedbiIm83/fHuP9C2xIqZPyoVkJ7OAbTktFicEBE1ttJSwMPD7tONUOH/hj2MTweOxg0P6eBXXUU5fntvOvxKC+q/mPL/qSaSYHFCROQoR48CAwY06BJXvPwxdNaGOmNOrbwfrSrKag9wdwfOnOG6KeQ0WJwQEckpN9c02+eKbVOIjVBh+cjpWD/4bxbfb5eXiV/+8xjUqOef5oEDgR9/5HRkUjQWJ0RETensWaBHD5tOKXXR4fU7puGTyLEW309+Y1z9OyUHBQFXr9r0uURyYXFCRKQEmZmmxy4VFTadluYTiNuf+FDSv2njIgy+fKr+dVOOHzfdySFSEBYnRERKU1oKPPoosGmT1afk61oh4uktFt9LWTG2/sc9KpVpYblevWzJlMghWJwQESmZjY99bpn9KbI9fS2+NzAjCV9/Pq/+iyj/n3dq5uz9/Vbb82GxsbEIDw+Hm5sbhgwZgkOHDtUZv2rVKnTv3h3u7u4ICwvDM888g7KyOkakExE1N927m4oFQQAOH643/I/YKUhdMQYJqx+RvJcY2hPhC3Yi172ef+xVKtNGg0ROxubiZMuWLYiJicHSpUuRmJiIiIgIjBo1CteuXbMYv3HjRixcuBBLly5FUlISPvzwQ2zZsgXPP/98g5MnInJKkZFVhUpKSp2hfqUFSF0xBj//518YknZC9N7AJzcifMFOPDXmOejVLpYv0Lu3qUg5erSxsidyOJsf6wwZMgS33HIL1qxZAwAwGo0ICwvD3LlzsXDhQkn8nDlzkJSUhLhqy0E/++yzOHjwIPbt22fxM8rLy1FeXrUXRUFBAcLCwvhYh4iar9OnTYWEFcIX7Kz1vWOrJsKnvLjuC3TqBPzxB+Br+bERUWOR5bGOXq9HQkICoqOjqy6gViM6OhoHDhyweM7QoUORkJBgfvSTkpKC3bt347777qv1c5YvXw4fHx/zKyys7l1AiYicXq9epjspERH1hqauGIMT7zwALwtFSMTTW5AY0r3uC6SkAH5+pjsq3t5ARoa9WRM5hE13Tq5cuYLQ0FD89ttviIqKMvfPnz8fP//8Mw4ePGjxvNWrV+O5556DIAiorKzEE088gffee6/Wz+GdEyJq0WzcKblSpcbwJz7EVW/xbsa/rHsU7fOzrP/cU6c4y4calawDYm0RHx+PZcuWYe3atUhMTMTXX3+NXbt24ZVXXqn1HJ1OB29vb9GLiKjF8PQEfv7ZdCfFigXWXAQjDrw3HU/8/qWo//YnPkT4gp1Yedsk3HDzqv9zb45Pee890w7NRE3Epjsner0eHh4e2LZtGyZMmGDunzp1KvLy8vDf//5Xcs7w4cNx66234s033zT3ff7555gxYwaKioqgVtdfH3EqMRG1eNnZQEBAvWEZXm0xbNbHtb7furQAy/bG4t6z+6Gq72JvvQU8+6xteRJVI8udE61Wi8jISNHgVqPRiLi4ONFjnupKSkokBYhGowEAOMESK0REytC2relOyrVrgEstM3MAhBZmm8ekPHx0DwIKr4vez3P3xqwJi9BxwU6EL9iJrX3vqv0zn3vOdCelfXtTcUQkE5tn62zZsgVTp07Ff/7zHwwePBirVq3C1q1bcebMGQQGBmLKlCkIDQ3F8uXLAQAvvfQSVq5ciffffx9DhgxBcnIyZs6cicjISGzZYnkVxJp454SIqIbSUuChh4AdO+oNFQBsjLgHL9wzp9aY39ZOQ0hhTt0XUqkAYz3L6BNVY+/vd+3ldy0mTpyI7OxsLFmyBJmZmejfvz/27NmDwMBAAEBaWproTsnixYuhUqmwePFiZGRkoG3bthg7dixee+01Wz+aiIhucncHbj5KHzMG2LWr1lAVgEnH9mDSsT0AgBwPH9w/6U2k+oaYY4bO2gAAGHc6Hv/3v7csP/IRBFOBcvWqacNBIgfh8vVERM1BaSkQHAzk59t02qJRs7Gp/72S/gNrpyK4xiMhi26/3VQYeXra9LnUMnBvHSIiMk1D7tkTuHzZptM+jhyLf0c/LumfcOonvL3rnfp3Re7XDzh2zKbPpOZPsVOJiYhIRp6eQHo6UF4OzJ5t9WnTE/6HiyvGYNph8RiW7b1HovP8HTjj36HuCxw/bnrkw4Gz1Ah454SIqLkzGIDPPwemTbMqPN0nELPGL8SJ4K6i/qDCHEw7/D88fGxP/UvkV1YCf87MpJaLj3WIiMg6GRlAu3ZWhc4eNx+7et5u8b03d72DB07GWXwPgOnx0qFDHI/SgvGxDhERWSc01DTzprDQNKC1DrE73sDxdx7EoMunJO/NG/0MFt81s/aTk5IALy+gVSvTWBgiK/HOCRERAVOmAJ99Vm+YAOCrPnfiudExov4nfv8ST+3fDPfKcssnAkBICJCWxsc9LQjvnBARkf0+/dQ0iLaeLUVUAO4/+SMSVz8i6l936wPo+exX+HTA6NpPvnLFtLrtu+82QsLUnPHOCRERiVk5JkUAMP/ep/BlP+kS+KPP/Ir/2/EmXOqagqz8nx9qIA6IJSKixlVUZBozYoWve49EzBjpJoGPHPkWr30XW/cmg8HBpjVS2ra1L09SLD7WISKixuXpabq7celSvaF/O/UTkt8Yh5U73xb1bxxwLzou2In/1jLjB4BpOfyAANM6KSEhXCuFeOeEiIhspNHUuwHgpdZBGPH4B5L+E+88AC99af2f4eZmWpKfnBrvnBARkTwMBiAlpc6QDnmZSF0xBjMOfiXq7/vMl7h/0gocD+pS92eUlZnupBgMDc2WnBDvnBARkf0uXgQ6daozpFzjgu7Pba/1/aS3/173FORVq4CnnrI3Q2pCHBBLRERNJyEBGDSozpD/9rwdT42bX+v7z/z6OZ76bXPtF0hJATp2tDdDagIsToiIqOmdPg307l1v2K7uwzB7wiJJ/7jT8Vj9v7fqPtnLy7T6bGiovVmSTFicEBGRcpw9C/ToUW9YmcYVnw0cg9fufFTU/8Dx7/Ha3lhojZV1X0D5P2EtGgfEEhGRcnTvbioc6lnMzc1Qgcf++AZn35og6v+y313oNm87dncfVvfnqFSmJfGpWeGdEyIicqz8fKB1a6tCP4och5ejZ0j6d308F72vXaz7ZOX/nLU4fKxDRETKdugQMGSIVaEv/WUGNgwaJ+kfmJGEbZ/Phxq1/HTl5QE+Pg3JkhoRixMiInIeVkxBrlSp8eS4+djd4zbp6SvG1L4kvloN5OaySFEAFidEROSc1Oo6H8kIADZFjMLz98wV9Xe6fhlxHzxRe5Hi6mp6pOTu3mipkm04IJaIiJyT0QisXVvr2yoAjxzbi9QVYxBx5Zy5P8WvHTou2In1t/zV8okVFYCHBzBhguX3SbF454SIiJTBYAA6d653o8Hf2vfDIw8vk/SnrBhb+1iUv/wF+OGHxsiSbMDHOkRE1DwUFZlm99Szr85/e47AU+Pmifr+fuIHvL17Ve0nccCsrPhYh4iImgdPT6CyErh2DajjB2180s/4PXaqqO+rvtEIX7ATHwwab/mk1q0BP7/GzJYcgMUJEREpU9u2pgGtgmA6tiCo6DpSV4zB7o/Eg2Vf/ctjyHWvpbDJzTUt3qZSmfYEIsXhYx0iInIOubn13vX4IuIevHDPHFHfx18uxciUeoqQwkLTHRtqVHysQ0REzZuvr+kuygcf1Boy6dge9MlMFvVNf+DfCF+wE4XaOqYUe3kBAwY0VqbUQLxzQkREzsdgAFxcan07tXUwZvxtMc617SDqf+n7dZiauLP2tVFUKtPUZmoUnK1DREQtTz27H+d4+GDQ3C8svpe4+hH4lhZYPlH5P41OgY91iIio5bm5+/Gjj1p8278kH6krxuDpfdICZeCTGzF37DwLZ8F0B4WaDIsTIiJyfh98AMyrpdAA8PT+TUhdMQZn35qA6PO/m/v/12sE3hvyd8snsUBpMnysQ0REzYdeb1rLpLS0zrCaq8zO/m0L5v36meVg5f9MKhYf6xAREWm1QEkJcP16nWFD047j2KqJ5nbs0IkIX7ATlSoLP4u8gyI7FidERNT83Jx2vHp1rSE+5cU4/O4kUV+X+Tuwo+ft0mAWKLJicUJERM3X3LmmpfDXrLH4tn9JPlJWjBX1PTluPvZ3iJAGd+zoiAzJAo45ISKilqOO9VF+6jQI0x94ydxOXTFGGsSNA23CMSdERET10WhqHeA6MuUw/nryR3N78V0zpUHBwY7KjKphcUJERC1PLQXKO7tWmo8/HzgaV7z8xQGlpUBRkSMzI7A4ISKilkoQAFdXSXf1WTz/mPiK9LxOnRyZFYHFCRERtWR6PTBxoqjLp7wY/a6eAwCk+IWh1EUnPic7u951VKhhWJwQEVHLtnmzpGvj5hfMx3PHWVh5tl07R2bU4rE4ISIiqqwUNT31VXdGfuh6K4w19zHOzeXYEwdicUJERKTRAJ07i7q++TTGfDxhytvScx580NFZtVgsToiIiAAgIUHUHPDnuBMAOB7cTRr/7beOzqjFYnFCREQEmBZX02hEXQmrHzEfnwzsXPMMchAWJ0RERDdduyZq+pUWmI93dx8mjc/NdXRGLRKLEyIiopt8fSVdAYWmHY639fmLNH6YhYKFGozFCRERUXVRUaLmnSmHAQDXvPyks3bOnJErqxaFxQkREVF1f/ubqLn0h/fNx4fb9ZLG5+c7OqMWh8UJERFRdU8+KWq6V5abj18b+U9p/OjRjs6oxWFxQkREVJ1WC+jES9bPOrAVAFCk85DGnzolR1YtCosTIiKiml58UdS8I8W0BsoFvzDpuJO8PMBgkCuzFoHFCRERUU3zxPvpdMq9bD5eM3RizWhg61ZHZ9SisDghIiKqSasVNf1Lqga9rhz+D2n8tGkOTqhlsas4iY2NRXh4ONzc3DBkyBAcOnSozvi8vDzMnj0bwcHB0Ol06NatG3bv3m1XwkRERLIICBA1V+94w3x8PKiLOFavlyOjFsPm4mTLli2IiYkvfuRMAAAgAElEQVTB0qVLkZiYiIiICIwaNQrXaqyqd5Ner8ddd92F1NRUbNu2DWfPnsX69esRGhra4OSJiIgc5tgxUXNc0i/m44NhfaXxnFLcaGwuTlauXInHHnsM06dPR69evbBu3Tp4eHjgo48+shj/0UcfITc3F9u3b8ewYcMQHh6OESNGICIiosHJExEROUxQkKSrbZFpufqdPYZL40eNcnRGLYZNxYler0dCQgKio6OrLqBWIzo6GgcOHLB4zo4dOxAVFYXZs2cjMDAQffr0wbJly2CoY2RzeXk5CgoKRC8iIiLZPfSQqHn7xUQAwLEQC7sUHz0qR0Ytgk3FSU5ODgwGAwIDA0X9gYGByMzMtHhOSkoKtm3bBoPBgN27d+PFF1/E22+/jVdffbXWz1m+fDl8fHzMr7CwMFvSJCIiahz/FC+6Nj3hf+ZjoWYsx500GofP1jEajQgICMD777+PyMhITJw4ES+88ALWrVtX6zmLFi1Cfn6++ZWenu7oNImIiKTuvFPUbH/jqvm43EU8oweCwAKlkdhUnPj7+0Oj0SArK0vUn5WVhSALz+YAIDg4GN26dYNGozH39ezZE5mZmdDX8h+iTqeDt7e36EVERCQ7jUa0WqynvtR8/J/Bf5PGr14tR1bNnk3FiVarRWRkJOLi4sx9RqMRcXFxiKqxi+NNw4YNQ3JyMoxGo7nv3LlzCA4OhrbGPHIiIiLFUVf9VKqrPcx5x9J6J9u2yZFRs2fzY52YmBisX78en3zyCZKSkjBz5kwUFxdj+vTpAIApU6Zg0aJF5viZM2ciNzcXTz31FM6dO4ddu3Zh2bJlmD17duP9FURERI7SsaOoeceFw7XHJiU5OJmWwcXWEyZOnIjs7GwsWbIEmZmZ6N+/P/bs2WMeJJuWlgZ1tSozLCwMe/fuxTPPPIN+/fohNDQUTz31FBYsWNB4fwUREZGj/Por4Odnbj5+8CvEdx4EACjXuEBnqKyKLSmRO7tmSSUIgmTAsdIUFBTAx8cH+fn5HH9CRETyU1Vt9mdQqdF5/g4AwKE1/0BAcZ44trLSNFaF7P795t46RERE9XFzMx9qhKoxlJ8OHCON/fZbOTJq1licEBER1afajB0AaFVuenyzZuhD0tjFi+XIqFljcUJERFSfXr1EzfvO7q899sIFByfT/LE4ISIiqk+NRzUPH9sDAAgovC6N5TIZDcbihIiIqD4+PoBL1QRXrz8f61zz8pPGdu0qV1bNFosTIiIia1TbdfhmcQIAFeoaM3P8/eXKqNlicUJERGSNq1X76rQtvmE+TmsdVGsc2YfFCRERkTWqjSWpPp34hnuN9TuKiuTKqNlicUJERGSNsjJRs9P1dABAhndbcdy5c4DBIFdWzRKLEyIiImtUVIiaKX5hAIDf2/eVxnIhtgZhcUJERGSN1q0tdu/ufpu088UXHZxM88bihIiIyBoTJoia0ed/BwDku3tJYy9elCOjZovFCRERkTWefFLUnJK4q/ZY5e+pq2gsToiIiKyh1Yo2AOzy54BYAChzqbEqbLU4sh2LEyIiImv5Va0IG1yYYz6WzNhxdZUro2aJxQkREZG1unUzH6qqdUvWOlHz57Uh+O0RERFZq0MHUTPoz7snl30CxXHp6YBeL1dWzQ6LEyIiImsdPixqZnqZ9tHZ3yFCGrt6tRwZNUssToiIiKxVYyG2vlfPAwCSAjpKY7/+Wo6MmiUWJ0RERNYaOVLUHHjlDADgZFAXaezly3Jk1CyxOCEiIrLWypWiZvXpxBI19uIh67E4ISIispa7O6Cqmqfzl+RD5mO92kUcW+MREFmPxQkREZEtqi2wVn2tk9OBncRxeXlyZdTssDghIiKyRbWl6auvdfJF/3ulsbm5js+nGWJxQkREZAtPT4vd/+11h7RzxAjH5tJMsTghIiKyxV//Kmo+fvArAIBKMEpjOWPHLixOiIiIbPF//ydq3pp2AgBQ7qqTxnLciV1YnBAREdnC3V20d05owTXzsVE0CuVP2dlyZNWssDghIiJqgI65GebjEY+vlwYMHChjNs0DixMiIiJbaTTmQ1ejwXyc3joIQs3YjIyaPVQPFidERES26iJerv7kOw+YjzO828qdTbPD4oSIiMhW+/aJmp76UvNxroePONanRpvqxeKEiIjIVr6+tb71R7te4o68PMBgsBxMFrE4ISIiskd4uMXuE0FdpZ07dzo2l2aGxQkREZE9QkJEzd6ZyQCA7b1HSmPnzpUjo2aDxQkREZE9aqwUe1vqUfPx5ZqDYtPT5cio2WBxQkREZI8nnxQ15/3yqfn4dECnmtFkAxYnRERE9tBqAVXVirAughEBhdcBAEkBHcWxLi5yZub0WJwQERHZa9AgUfOalx8A4Ia7tziushLQ6+XKyumxOCEiIrKXTrzZX/T5gwCAs207SGNXrZIjo2aBxQkREZG9xo8XNd0rygAAxVp3aewnn8iRUbPA4oSIiMheNQbFds+5BAA4HtxNGpuZKUdGzQKLEyIiIntptYC66qe0x7VU87FkA8CKCllSag5YnBARETWEq6v5cMCVM+bj3JqDYgsL5crI6bE4ISIiagij0XzoW1pgPv5fz9ulsUVFcmTk9FicEBERNYR71eBXVbXudbfeL42dPNnx+TQDLE6IiIgaIjJS1Gx/4yoAoPP1y9LY5GQ5MnJ6LE6IiIgaYsECUfO5Xz8DAJS4ukljvb2lfSTB4oSIiKghoqNFTRejAQBwJLSHNHboUDkycnosToiIiBpCowGiosxND30pACA894o09uJFubJyaixOiIiIGurCBfPhzRk7qb4h0KtrbPj3669yZuW0WJwQERE11PXr5sOwvCzz8e4et4njcnLkysipsTghIiJqKFXVJOI2ZVWLreW0ai2OMxoBg0GurJwWixMiIqKG6tpV1Iw+/zsA4LxfmDQ2Lk6OjJwaixMiIqKGevZZUbPcRQsAuO7RWhr78cdyZOTU7CpOYmNjER4eDjc3NwwZMgSHDh2y6rzNmzdDpVJhwoQJ9nwsERGRMnXuLGqGFmQDAA607yuNPXZMjoycms3FyZYtWxATE4OlS5ciMTERERERGDVqFK5du1bneampqXjuuecwfPhwu5MlIiJSpBq/bf2ungMAFOs8pLH1/F6SHcXJypUr8dhjj2H69Ono1asX1q1bBw8PD3z00Ue1nmMwGDBp0iT8+9//RqdOnRqUMBERkeJoNIBL1bTh7jmXzMdG0Y47AIqL5crKadlUnOj1eiQkJCC62mp4arUa0dHROHDgQK3nvfzyywgICMCjjz5q1eeUl5ejoKBA9CIiIlK0asVJ36tVe+j8bunRDtXJpuIkJycHBoMBgYGBov7AwEBkZmZaPGffvn348MMPsX79eqs/Z/ny5fDx8TG/wsIsjHYmIiJSkmr75miNleZjyR473F+nXg6drVNYWIjJkydj/fr18Pf3t/q8RYsWIT8/3/xKT093YJZERESNoFcvUTPy8mkAwAW/dnXGkZRL/SFV/P39odFokJWVJerPyspCUFCQJP7ChQtITU3F2LFjzX1Go9H0wS4uOHv2LDrXGOEMADqdDjqdzpbUiIiImlZIiKh53r89AKDVn3vt1BZHUjbdOdFqtYiMjERctQVkjEYj4uLiEFVt06ObevTogRMnTuDo0aPm17hx4zBy5EgcPXqUj2uIiKj5aN9e1Bx+MREAYFBrxHHJyaC62XTnBABiYmIwdepUDBo0CIMHD8aqVatQXFyM6dOnAwCmTJmC0NBQLF++HG5ubujTp4/o/NatTQvS1OwnIiJyajWGL7j8+aQgxTdUHHfoEKDXA1qtXJk5HZuLk4kTJyI7OxtLlixBZmYm+vfvjz179pgHyaalpUGt5sKzRETUwtQY3pDaJhgAcM6/vTR2zRogJkaOrJySzcUJAMyZMwdz5syx+F58fHyd527YsMGejyQiIlK2UPEdkuDCHBxDdxhUFv4P+88/szipA29xEBERNYbhw4FqTw4GXDkLALjhYWHqMGeh1onFCRERUWPQaICAAHMz/MYVAMB5/w7S2JISubJySixOiIiIGku1osOnrMh8LFnC/upVuTJySixOiIiIGku14iQyI8l8LJmxU1QEqh2LEyIiosaiqrpD4mo0mI/XD/6rOM5oBAwGkGUsToiIiBqLp6fFbqOlGTvVFjQlMRYnREREjWXYMFHzoWN7AQBXvS3sL/fhh3Jk5JRYnBARETWWTZtETd+SfADAvvAB0tj9++XIyCmxOCEiImosNR7reJUXm4+FmrE1NtGlKixOiIiIHOShY9+Zj8+0DRe/WVkpbzJOhMUJERFRY9JU7ULcpqzQfLy/Q4Q0trRUjoycDosTIiKixuQtXq7eXV8GADgR1FUa++yzcmTkdFicEBERNaYaM3buO7sPAFCk85DG/v67HBk5HRYnREREjanGjJ2Iq+cBAHFdBktjMzLkyMjpsDghIiJqTDVm7AQU5ZqPC7Xu4tjr1+XIyOmwOCEiInKgu89XPbo5GNZX/KbBwGXsLWBxQkRE1NhcXc2HagjQVlYAABJDe0hjuYy9BIsTIiKixta+vagZmXEaAHA6oJM09v335cjIqbA4ISIiamx33SVqds++BACI7zxIGvvDD3Jk5FRYnBARETW2lStFzXvPVu2jI1nGvqTE8fk4GRYnREREjc1dPCsn4uo58/Fln0C5s3E6LE6IiIgcodpKsW6GCvPxH+16ieNqFDLE4oSIiMgxvLxETW2lHgBgUNX46TUa5crIabA4ISIicoT+/UXNoZeOAwDOBHQUxxUVAXq9XFk5BRYnREREjtCnj6iZ3to01iS1TYg0dvVqOTJyGixOiIiIHKHaQmwAEJaXBQBICgiXxm7bJkNCzoPFCRERkSPccYeoOfDKGQBAjkcbaWxSkgwJOQ8WJ0RERI5Qozjpm2nanVjv4gojVOJYjjkRYXFCRETkCBoN4OZmbg6/eMR8fMXbXxyr5s9xdfw2iIiIHMXT03zoIlRNGT7n30EcV1LC3YmrYXFCRETkKLU8rvm2+zBp53ffOTgZ58HihIiIyFE8PETN4IJsAECFxkUa+/bbcmTkFFicEBEROcqTT4qafz8ZBwA4GNZHGpuWJkdGToHFCRERkaM8+6yo2eX6ZQBAqatOGlttfEpLx+KEiIjIUbRaoHt3c7PDjSsAgDx3b2lsjUdALRmLEyIiIkeqVpy4Giprj0tI4IydP7E4ISIicqRvvzUfBhTnmo+TfduJ48rKgF9/lSsrRWNxQkRE5EiVVXdL2pQWmo8/H3CfNDYjQ46MFI/FCRERkSO1amU+dDUa8LcTphk75S5aaSyLEwAsToiIiBzr1ClRs0dOKgDgmqevNHbvXhkSUj4WJ0RERI7Uvr2oGVhoGncS12WwNPbcOTkyUjwWJ0RERI7Wtav50Ku8GAAQVJgjjXN3lysjRWNxQkRE5GjXr5sPgwpNx5le/ih2dRPHpafLmZVisTghIiJytPx882HX61XL1L936/3iuLKyWjcLbElYnBARETmauurn1tVYtdDagfb9pLGrV8uRkaKxOCEiInK0Xr1EzX5XTQNfTwV2ksZ+9ZUcGSkaixMiIiJHW75c1Bx54TAAoKzmmBMASE6WIyNFY3FCRETkaHffLWpGpR2vPba83MHJKB+LEyIiIkfTaEQrxUZcPW8+znPzFMe6usqVlWKxOCEiIpJDUJD50L2y6u5IjkdrcVybNnJlpFgsToiIiOTg72+x+6JviFVxLQmLEyIiIjlUVFjsvuHuLe64dk2GZJSNxQkREZEcQsR3SDpdN60GK3msc/kyYDCgJWNxQkREJAeVStT0LS0AACT7izcGREUFEB8vU1LKxOKEiIhIDu3aiZpulaZl6g+16yWN3bNHjowUy67iJDY2FuHh4XBzc8OQIUNw6NChWmPXr1+P4cOHo02bNmjTpg2io6PrjCciImqWunUTNVuVlwIAPPWl0tivv5YjI8WyuTjZsmULYmJisHTpUiQmJiIiIgKjRo3CtVoG8MTHx+Phhx/GTz/9hAMHDiAsLAx33303MjIyGpw8ERGR05g1S9R88MT3AIAzAR2lsVlZcmSkWCpBEARbThgyZAhuueUWrFmzBgBgNBoRFhaGuXPnYuHChfWebzAY0KZNG6xZswZTpkyx6jMLCgrg4+OD/Px8eHt7138CERGRErm4mAe7Jvu2Q/Rj6wAA596cAK2xsipOpzPtUOzk7P39tunOiV6vR0JCAqKjo6suoFYjOjoaBw4csOoaJSUlqKiogK+vb60x5eXlKCgoEL2IiIicXrXfvvAbV8zHWV5+4rjy8hY9Y8em4iQnJwcGgwGBgYGi/sDAQGRmZlp1jQULFiAkJERU4NS0fPly+Pj4mF9hYWG2pElERKRMxcXmQxfBaD7e0fN2aex338mRkSLJOlvn9ddfx+bNm/HNN9/Azc3CTox/WrRoEfLz882v9PR0GbMkIiJykBrTiW96d+hEaefbbzs4GeWyqTjx9/eHRqNBVo2BOllZWQiqtmeAJW+99RZef/11fPfdd+jXr1+dsTqdDt7e3qIXERGR0+vbV9QcfjERANDr2kVpbFqaHBkpkk3FiVarRWRkJOLi4sx9RqMRcXFxiIqKqvW8N954A6+88gr27NmDQYMG2Z8tERGRM6uxfsnkxF0AgFMBnaSx1XYxbmlcbD0hJiYGU6dOxaBBgzB48GCsWrUKxcXFmD59OgBgypQpCA0NxfLlywEAK1aswJIlS7Bx40aEh4ebx6Z4enrC09Oz1s8hIiJqdnx8RE2jynSPoNxVJ41twdOJbS5OJk6ciOzsbCxZsgSZmZno378/9uzZYx4km5aWBrW66obMe++9B71ej/vvv190naVLl+Kll15qWPZERETORq0GjKbBsD2zqx7nnPHvgB45l6rirl4F9HpAq5U7wyZn8zonTYHrnBARUbNRY1Bs+IKdAIC7zx3A+9+8Jo595RVg8WK5Mmt0sqxzQkRERA1UY0jDrZeOAwC+62Zh7OZrr0n7WgAWJ0RERHI6dUrUHJ56xHxcUnPsSVlZi1yMjcUJERGRnNq3FzWfOPiV+fjdqIek8d9+6+iMFIfFCRERkdxcXc2HmmorxX7d505prBOPObEXixMiIiK5DRwoai754X0AQKHOQxp7/rwcGSkKixMiIiK57d0rao64mAAAKNG6Q6+uscoHx5wQERGRw9VYjK1jbtUOxSm+oeJYnYUF2po5FidERERNodq6H2pULTn2W4cIcVxJiVwZKQaLEyIioqZQyxYuxpo7F1dWAqWlMiSkHCxOiIiImkKNKcUTTv0EAPgkcqw0duZMOTJSDBYnRERETaF/f1HzVKBpZ+L01kHS2E2b5MhIMVicEBERNYXu3UXNV757z3ycr2sljtXr5chIMVicEBERNYVZs0TNW9NPmo839r9HGt+CphSzOCEiImoKWi2g0Vh8q0BnYbBsXJyDE1IOFidERERN5ZZbRM0Hjn8PANjUf5Q0dv16OTJSBBYnRERETWXPHlGzUm26k5Ln7i2NjY+XISFlYHFCRETUVGqsFHvf2X3mY8ky9gUFcmSkCCxOiIiImpK7u/lw5IXD5uPLPgHiuFrGpzRHLE6IiIiakq+v+dBFMJqP891qDIotK5MroybH4oSIiKgpGY2iZtecSwCAnzqLB8tCEIDsbLmyalIsToiIiJpSjeKkQu0KAFg97GFpbESEtK8ZYnFCRETUlEJDRc0piTvNxzfcvMSxV6/KkVGTY3FCRETUlF59VdScnrDDfPz5gPvkzkYRWJwQERE1pbvvFjVVAFwMlQAAvYurOLaFzNhhcUJERNSUNBqgVy9R193nfwcAqATxeBQYDC1ijx0WJ0RERE1t5UpRM7DoOgDgYFhfaezmzXJk1KRYnBARETW16GhR84JvOwDAwfZ9IdSMnTxZnpyaEIsTIiKiplZjLMnkI7vMx+f8O4hjBQEoLZUjqybD4oSIiEhh7ko+ZD6eOWGhNODRR2XMRn4sToiIiJSgbVuL3Sl+YTBCJe7ctEmGhJoOixMiIiIluPVWUfOrz58zH2/td5c0vhkvZc/ihIiISAk2bhQ1IzPOmI9X3jZJGt+tm6MzajIsToiIiJTA0xNwFS+6Nu2wabXYa15+yPT0E8fn5TXbNU9YnBARESlFZqaoufjHD8zHX/W5Uxq/c6e0rxlgcUJERKQUvr6ipotgxOikXwAAb46YKo1/8kk5spIdixMiIiIlmTZN1PQrKTAfl7jqxLFpaTIkJD8WJ0REREqydq2o+eKP683Hv3QcKI3PzXV0RrJjcUJERKQk7u6ipquxatDrG7dPkcZ37uzojGTH4oSIiEhpevYUNaPPHwRgWpCtTCOe0YO8PECvlyszWbA4ISIiUpoa407e277MfPzu0Iek8f36OTghebE4ISIiUpqnnxY1qz/aiR06URp/9myz2gyQxQkREZHSaLVAYKCoa+OmRebjl+/8l/Scxx5zdFayYXFCRESkRGfPippD006Yjz+6ZYI0/osvHJ2RbFicEBERKZGPD6AS70b82p415uOtfS1sBhgb6+isZMHihIiISKmuXBE1Jx3bYz6ef99TEGrGz5nTLPbbYXFCRESkVEFBkq7Xv11tPv7glr9Kz3FxcWRGsmBxQkREpGTXromaDx3/znz82p2PStc9AUyPhJwYixMiIiIla9tW0rVh6xLzcY/nvpGeU1Bg8a6Ls2BxQkREpHTXr4uad1xMFLWXRj8uPScry2n33WFxQkREpHS+vpKZO6krxpiPP4kci9dG/lN6np+fozNzCBYnREREzuDGDUnX5o0LzcfrB/8Nqa2DpeepVEBysiMza3QsToiIiJyBjw8QEiLqujX9JA7GVu1UfMfj65HuHSA9t2tXyZ0XJWNxQkRE5CwyMiRdgUW5WBy33twePvMjZHhJB9ECMBUoCQmOyq7RsDghIiJyJoJk6TX86/B/8dihr83tYbM+xrGgrpbPHzTIVKSoVICHB5CW5qhM7cbihIiIyNlUVkq6XvjpI7zy3Vpze/zUd/Do35dI4kRKS4EOHQBXC2ulNCG7ipPY2FiEh4fDzc0NQ4YMwaFDh+qM//LLL9GjRw+4ubmhb9++2L17t13JEhEREQCNBti6VdI9+chufL75BXM7rstghC/YiZ09bqv7epWViipQbC5OtmzZgpiYGCxduhSJiYmIiIjAqFGjcK3GCnY3/fbbb3j44Yfx6KOP4siRI5gwYQImTJiAkydPNjh5IiKiFuuBB4C5cyXdt106htMr/y7qmzN+IR5+6DUcCe4GI2oZGFtZqZhHPCpBsPDwqg5DhgzBLbfcgjVrTDsjGo1GhIWFYe7cuVi4cKEkfuLEiSguLsbOnTvNfbfeeiv69++PdevWWfWZBQUF8PHxQX5+Pry9vW1Jl4iIqHnr0gW4cMHiW7u7D8OsCYukp+Sk4W8nf8TMg9vEpYq7O1BS0mip2fv7bdOdE71ej4SEBERHR1ddQK1GdHQ0Dhw4YPGcAwcOiOIBYNSoUbXGA0B5eTkKCgpELyIiIrIgOdk0yNWC+87ux8UVY7Dwp4/Fp/i3xxt3TMNPnWqcV1rqqCxtYlNxkpOTA4PBgMDAQFF/YGAgMjMzLZ6TmZlpUzwALF++HD4+PuZXWFiYLWkSERG1LH/8ARQWWnxLBeCJQ18hdcUYnHtzAjZueh6uhgqMSDkM7/JicbBaGfNkFLmv8qJFixATE2NuFxQUsEAhIiKqi6enaZqxv79kL56btMZKDE07jnNv/dXyyJNJkxyaorVsKk78/f2h0WiQlZUl6s/KykJQLbsfBgUF2RQPADqdDjqdzpbUiIiICAByckwb/tWxr06ta8X+5z8OSclWNt2/0Wq1iIyMRFxcnLnPaDQiLi4OUVFRFs+JiooSxQPA999/X2s8ERERNZCvr+kuyuuvW3/O+PGmAbEKYPPDpZiYGKxfvx6ffPIJkpKSMHPmTBQXF2P69OkAgClTpmDRoqqRwU899RT27NmDt99+G2fOnMFLL72Ew4cPY86cOY33VxAREZHUggWmKcJ/zrCt1fjxwPbt8uRkBZvHnEycOBHZ2dlYsmQJMjMz0b9/f+zZs8c86DUtLQ3qagNqhg4dio0bN2Lx4sV4/vnn0bVrV2zfvh19+vRpvL+CiIiILNNogNmzTS/ANCNn3jzg/HnThoBvvqmYOyY32bzOSVPgOidERETOR5Z1ToiIiIgcjcUJERERKQqLEyIiIlIUFidERESkKCxOiIiISFFYnBAREZGisDghIiIiRWFxQkRERIrC4oSIiIgUhcUJERERKQqLEyIiIlIUmzf+awo3t/8pKCho4kyIiIjIWjd/t23dxs8pipPCwkIAQFhYWBNnQkRERLYqLCyEj4+P1fFOsSux0WjElStX4OXlBZVK5ZDPKCgoQFhYGNLT07nzsYPwO3Y8fseOx+/Y8fgdO55c37EgCCgsLERISAjUautHkjjFnRO1Wo127drJ8lne3t78H4OD8Tt2PH7Hjsfv2PH4HTueHN+xLXdMbuKAWCIiIlIUFidERESkKJqXXnrppaZOQik0Gg3uuOMOuLg4xdMup8Tv2PH4HTsev2PH43fseEr+jp1iQCwRERG1HHysQ0RERIrC4oSIiIgUhcUJERERKQqLEyIiIlIUFidERESkKC2qOImNjUV4eDjc3NwwZMgQHDp0qM74L7/8Ej169ICbmxv69u2L3bt3y5Sp87LlO16/fj2GDx+ONm3aoE2bNoiOjq73PxOy/b/HN23evBkqlQoTJkxwcIbOz9bvOC8vD7Nnz0ZwcDB0Oh26devGfy/qYet3vGrVKnTv3h3u7u4ICwvDM888g7KyMpmydT6//PILxo4di5CQEKhUKmzfvr3ec+Lj4zFw4EDodDp06dIFGzZscHyitRFaiM2bN8QeUNcAAAZVSURBVAtarVb46KOPhFOnTgmPPfaY0Lp1ayErK8ti/P79+wWNRiO88cYbwunTp4XFixcLrq6uwokTJ2TO3HnY+h0/8sgjQmxsrHDkyBEhKSlJmDZtmuDj4yNcvnxZ5sydh63f8U0XL14UQkNDheHDhwvjx4+XKVvnZOt3XF5eLgwaNEi47777hH379gkXL14U4uPjhaNHj8qcufOw9Tv+4osvBJ1OJ3zxxRfCxYsXhb179wrBwcHCM888I3PmzmP37t3CCy+8IHz99dcCAOGbb76pMz4lJUXw8PAQYmJihNOnTwvvvvuuoNFohD179siUsViLKU4GDx4szJ4929w2GAxCSEiIsHz5covxDz74oDB69GhR35AhQ4THH3/coXk6M1u/45oqKysFLy8v4ZNPPnFUik7Pnu+4srJSGDp0qPDBBx8IU6dOZXFSD1u/4/fee0/o1KmToNfr5UrR6dn6Hc+ePVu48847RX0xMTHCsGHDHJpnc2FNcTJ//nyhd+/eor6JEycKo0aNcmRqtWoRj3X0ej0SEhIQHR1t7lOr1YiOjsaBAwcsnnPgwAFRPACMGjWq1viWzp7vuKaSkhJUVFTA19fXUWk6NXu/45dffhkBAQF49NFH5UjTqdnzHe/YsQNRUVGYPXs2AgMD0adPHyxbtgwGg0GutJ2KPd/x0KFDkZCQYH70k5KSgt27d+O+++6TJeeWQGm/ecpbs9YBcnJyYDAYEBgYKOoPDAzEmTNnLJ6TmZlpMT4zM9NheToze77jmhYsWICQkBDJ/0DIxJ7veN++ffjwww9x9OhROVJ0evZ8xykpKfjxxx8xadIk7N69G8nJyZg1axYqKiqwdOlSOdJ2KvZ8x4888ghycnJw2223QRAEVFZW4oknnsDzzz8vR8otQm2/eQUFBSgtLYW7u7us+bSIOyekfK+//jo2b96Mb775Bm5ubk2dTrNQWFiIyZMnY/369fD392/qdJoto9GIgIAAvP/++4iMjMTEiRPxwgsvYN26dU2dWrMRHx+PZcuWYe3atUhMTMTXX3+NXbt24ZVXXmnq1MhBWsSdE39/f2g0GmRlZYn6s7KyEBQUZPGcoKAgm+JbOnu+45veeustvP766/jhhx/Qr18/R6bp1Gz9ji9cuIDU1FSMHTvW3Gc0GgEALi4uOHv2LDp37uzYpJ2MPf89Dg4OhqurKzQajbmvZ8+eyMzMhF6vh1ardWjOzsae7/jFF1/E5MmT8a9//QsA0LdvXxQXF2PGjBl44YUXoFbz/2c3VG2/ed7e3rLfNQFayJ0TrVaLyMhIxMXFmfuMRiPi4uIQFRVl8ZyoqChRPAB8//33tca3dPZ8xwDwxhtv4JVXXsGePXswaNAgOVJ1WrZ+xz169MCJEydw9OhR82vcuHEYOXIkjh49irCwMDnTdwr2/Pd42LBhSE5ONhd+AHDu3DkEBwezMLHAnu+4pKREUoDcLAYF7l3bKBT3m9ckw3CbwObNmwWdTids2LBBOH36tDBjxgyhdevWQmZmpiAIgjB58mRh4cKF5vj9+/cLLi4uwltvvSUkJSUJS5cu5VTietj6Hb/++uuCVqsVtm3bJly9etX8KiwsbKo/QfFs/Y5r4myd+tn6HaelpQleXl7CnDlzhLNnzwo7d+4UAgIChFdffbWp/gTFs/U7Xrp0qeDl5SVs2rRJSElJEb777juhc+fOwoMPPthUf4LiFRYWCkeOHBGOHDkiABBWrlwpHDlyRLh06ZIgCIKwcOFCYfLkyeb4m1OJ582bJyQlJQmxsbGcSiyXd999V2jfvr2g1WqFwYMHC7///rv5vREjRghTp04VxW/dulXo1q2boNVqhd69ewu7du2SOWPnY8t33KFDBwGA5LV06VL5E3citv73uDoWJ9ax9Tv+7bffhCFDhgg6nU7o1KmT8NprrwmVlZUyZ+1cbPmOKyoqhJdeekno3Lmz4ObmJoSFhQmzZs0Sbty40QSZO4effvrJ4r+vN7/XqVOnCiNGjJCc079/f0Gr1QqdOnUSPv74Y9nzvkklCLwnRkRERMrRIsacEBERkfNgcUJERESKwuKEiIiIFIXFCRERESkKixMiIiJSFBYnREREpCgsToiIiEhRWJwQERGRorA4ISIiIkVhcUJERESKwuKEiIiIFOX/ATUotIK3zVpaAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib\n",
    "matplotlib.rcParams['agg.path.chunksize'] = 1920000200000000\n",
    "matplotlib.rcParams.update( matplotlib.rc_params() )\n",
    "plt.plot(pr_curve[:,0],pr_curve[:,1])\n",
    "plt.scatter(precision_pts[:,0],precision_pts[:,1],color='r')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.805629502041341"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.mean(precision_pts[:,1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.8189646193634157"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.mean(precision_pts[:,1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import cv2\n",
    "from matplotlib import pyplot as plt\n",
    "\n",
    "img = test_data[0]['img']\n",
    "\n",
    "fast=cv2.FastFeatureDetector_create(threshold=20,nonmaxSuppression=True,type=cv2.FAST_FEATURE_DETECTOR_TYPE_9_16)#获取FAST角点探测器\n",
    "\n",
    "\n",
    "kp=fast.detect(img,None)#描述符\n",
    "\n",
    "img = cv2.drawKeypoints(img,kp,img,color=(255,0,0))#画到img上面\n",
    "\n",
    "print (\"Threshold: \", fast.getThreshold())#输出阈值\n",
    "print (\"nonmaxSuppression: \", fast.getNonmaxSuppression())#是否使用非极大值抑制\n",
    "print (\"Total Keypoints with nonmaxSuppression: \", len(kp))#特征点个数\n",
    "\n",
    "plt.imshow(img)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 检查方法是否正确"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_data = get_test({\"SyntheticData\":{\"only_point\":True}},loader=False)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "sample_index = random.sample(list(range(0,1000))+list(range(1500,3500)),1000)\n",
    "test_sample = [test_data[i] for i in sample_index]\n",
    "\n",
    "# test_sample = [test_data[i] for i in range(1,-1,-1)]\n",
    "\n",
    "# 0~500 checkerboard 0.9553\n",
    "# 500~1000 cube 0.9734\n",
    "# 1000~1500 ellipse ???\n",
    "# 1500~2000 line 0.9437 ??? 前后有影响？？"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "del pr_curve,precision_pts"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 1000/1000 [00:34<00:00, 29.15it/s]\n",
      "100%|██████████| 19200000/19200000 [00:27<00:00, 686360.22it/s]\n"
     ]
    }
   ],
   "source": [
    "pr_curve,precision_pts = mAP_final(test_sample)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.9136004782594761\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib\n",
    "from dataset import visulize\n",
    "\n",
    "sample = test_sample[0]\n",
    "heatmap = get_heatmap(sample)\n",
    "print(np.mean(precision_pts[:,1]))\n",
    "matplotlib.rcParams['agg.path.chunksize'] = 1920000200000000\n",
    "matplotlib.rcParams.update( matplotlib.rc_params() )\n",
    "plt.plot(pr_curve[:,0],pr_curve[:,1])\n",
    "plt.scatter(precision_pts[:,0],precision_pts[:,1],color='r')\n",
    "plt.show()\n",
    "\n",
    "plt.imshow(heatmap)\n",
    "plt.show()\n",
    "\n",
    "plt.imshow(sample['img'])\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0 0 0 ... 0 0 0]\n",
      " [0 0 0 ... 0 0 0]\n",
      " [0 0 0 ... 0 0 0]\n",
      " ...\n",
      " [0 0 0 ... 0 0 0]\n",
      " [0 0 0 ... 0 0 0]\n",
      " [0 0 0 ... 0 0 0]]\n"
     ]
    }
   ],
   "source": [
    "print(point2label(sample['pt'],binary=True))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "superpoint",
   "language": "python",
   "name": "superpoint"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
